praxis-agent 0.12.0 → 0.13.0

package/README.md

@@ -15,6 +15,11 @@ Anthropic/OpenAI-compatible model access. Praxis deliberately excludes
 accounts, organizations, billing, managed enterprise policy, remote control,
 IDE surfaces, and telemetry control planes.
 
+Claude Code 2.1.208 is the compatibility, architecture, and design baseline.
+Every single-user CLI capability remains required unless it falls inside an
+explicit exclusion above. A similar Praxis surface is not a substitute for the
+corresponding Claude command or runtime contract.
+
 ## Requirements
 
 - macOS or Linux
@@ -87,8 +92,10 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   `/rewind`, runtime `/cd`, transcript-free
   `/btw` side questions with background-Agent handoff, interactive
   `/background` terminal handoff, unified `/status`/`/config`/`/usage` settings
-  tabs, `/sandbox` mode/dependency/override/config controls, `/mcp`, `/memory` shared
-  instruction and auto-memory access, and live extension-reload controls,
+  tabs, `/sandbox` mode/dependency/override/config controls, local cached
+  `/release-notes`, Claude-compatible `/statusline` command execution and setup
+  agent, `/mcp`, `/memory` shared instruction and auto-memory access, and live
+  extension-reload controls,
   cursor/history composer, per-session model/effort/permission controls,
   context/status/skill/task dashboards, prompt stash and continuation shortcuts,
   filterable `@` file and agent references, composer undo, `Ctrl+G` external

package/dist/application/subagent-service.d.ts

@@ -1,7 +1,7 @@
 import { type ClaudeSidechainPermissionMode } from '../compatibility/claude/sidechain.js';
 import { type ContextAssembler } from '../core/context.js';
 import { type ModelProvider, type ModelToolCall, type ModelToolDefinition, type ModelUsage, type PermissionResolver, type PermissionApproval, type PermissionDecision, type PermissionUpdate, type RuntimeEventSink, type ToolExecutionContext, type ToolExecutionResult, type ToolRegistry } from '../core/runtime.js';
-import type { ClaudeExtensionCatalog } from '../extensions/claude-extensions.js';
+import { type ClaudeExtensionCatalog } from '../extensions/claude-extensions.js';
 import type { ClaudeHookRunner } from '../hooks/claude-hooks.js';
 import { type BackgroundAgentSnapshot } from './background-agent-manager.js';
 export interface WorkflowAgentRunOptions {

package/dist/application/subagent-service.js

@@ -11,6 +11,7 @@ import { createClaudeHookAttachmentEntries, translateProviderEvents, } from '../
 import { injectFirstUserMessageContext, } from '../core/context.js';
 import { ContextBudget } from '../core/context-budget.js';
 import { AgentRuntime, } from '../core/runtime.js';
+import { BUILTIN_STATUSLINE_AGENT_PATH, } from '../extensions/claude-extensions.js';
 import { ClaudeHookToolCoordinator } from '../hooks/claude-hook-tools.js';
 import { ClaudeSidechainStore } from '../persistence/claude-sidechain-store.js';
 import { InMemorySidechainStore } from '../persistence/in-memory-sidechain-store.js';
@@ -79,6 +80,29 @@ export class StructuredOutputRegistry {
         });
     }
 }
+class RestrictedToolRegistry {
+    base;
+    allowed;
+    constructor(base, names) {
+        this.base = base;
+        this.allowed = new Set(names);
+    }
+    definitions() {
+        return this.base
+            .definitions()
+            .filter((definition) => this.allowed.has(definition.name));
+    }
+    prepare(call, context) {
+        if (!this.allowed.has(call.name))
+            throw new Error(`Tool ${call.name} is unavailable to this agent`);
+        return this.base.prepare(call, context);
+    }
+    execute(call, context) {
+        if (!this.allowed.has(call.name))
+            throw new Error(`Tool ${call.name} is unavailable to this agent`);
+        return this.base.execute(call, context);
+    }
+}
 function parseAgentInput(call) {
     const allowed = new Set([
         'description',
@@ -942,9 +966,16 @@ export class ClaudeSubagentExecutor {
             permission_mode: options.input.permissionMode ?? 'default',
         };
         const nestedTools = this.registry(String(options.root.sessionId), options.spawnDepth, () => options.promptId);
-        const agentTools = options.outputSchema
-            ? new StructuredOutputRegistry(structuredOnlyTools, options.outputSchema, options.structuredOutput)
+        const builtInStatusLineAgent = this.options.extensions?.agent(options.input.subagentType)?.path ===
+            BUILTIN_STATUSLINE_AGENT_PATH;
+        const scopedTools = builtInStatusLineAgent
+            ? new RestrictedToolRegistry(nestedTools, ['Read', 'Edit'])
             : nestedTools;
+        const agentTools = options.outputSchema
+            ? new StructuredOutputRegistry(builtInStatusLineAgent
+                ? new RestrictedToolRegistry(structuredOnlyTools, ['Read', 'Edit'])
+                : structuredOnlyTools, options.outputSchema, options.structuredOutput)
+            : scopedTools;
         const runtimeTools = this.options.hooks
             ? new ClaudeHookToolCoordinator({
                 tools: agentTools,

package/dist/cli/interactive.d.ts

@@ -175,8 +175,10 @@ interface InteractiveAppProps {
     runtimeSettingsTarget?: ConfigSettingsTarget;
     notificationWriter?: TuiNotificationWriter;
     elicitationUrlOpener?: (url: string) => void | Promise<void>;
+    releaseNotesLoader?: (configRoot: string) => Promise<string>;
+    settingSources?: readonly ClaudeResourceScope[];
 }
-export declare function InteractiveApp({ factory, initialSessions, initialPrompt, initialHistory, signal, onCancel, onTurnChange, onCleanup, onRendererChange, onBackground, axScreenReader, allowNewSession, resume, display, terminalWidth, slashCommands, agents, allowDangerouslySkipPermissions, additionalDirectories, diffLoader, fileLoader, externalEditor, keybindingsConfigRoot, keybindingsFile, keybindingsLoader, keybindingsEditor, memoryFilesLoader, memoryEditor, memoryFolderOpener, suspendProcess, clipboardReader, clipboardWriter, sideQuestionClipboardWriter, exportWriter, permissionRuleStore, sandboxStore: suppliedSandboxStore, recentlyDeniedStore: suppliedRecentlyDeniedStore, terminalSetup: terminalSetupOverride, themeStore, initialThemeSettings, initialThemeLoadError, workspaceDirectoryResolver, workspaceDirectoryCompleter, runtimeSettings: suppliedRuntimeSettings, runtimeSettingsTarget, notificationWriter, elicitationUrlOpener, }: InteractiveAppProps): import("react").JSX.Element;
+export declare function InteractiveApp({ factory, initialSessions, initialPrompt, initialHistory, signal, onCancel, onTurnChange, onCleanup, onRendererChange, onBackground, axScreenReader, allowNewSession, resume, display, terminalWidth, slashCommands, agents, allowDangerouslySkipPermissions, additionalDirectories, diffLoader, fileLoader, externalEditor, keybindingsConfigRoot, keybindingsFile, keybindingsLoader, keybindingsEditor, memoryFilesLoader, memoryEditor, memoryFolderOpener, suspendProcess, clipboardReader, clipboardWriter, sideQuestionClipboardWriter, exportWriter, permissionRuleStore, sandboxStore: suppliedSandboxStore, recentlyDeniedStore: suppliedRecentlyDeniedStore, terminalSetup: terminalSetupOverride, themeStore, initialThemeSettings, initialThemeLoadError, workspaceDirectoryResolver, workspaceDirectoryCompleter, runtimeSettings: suppliedRuntimeSettings, runtimeSettingsTarget, notificationWriter, elicitationUrlOpener, releaseNotesLoader, settingSources, }: InteractiveAppProps): import("react").JSX.Element;
 export declare function runInteractive(options: {
     factory: InteractiveServiceFactory;
     initialPrompt?: string;
@@ -192,6 +194,7 @@ export declare function runInteractive(options: {
     onBackground?: (request: InteractiveBackgroundRequest) => Promise<InteractiveBackgroundResult>;
     onBackgrounded?: (result: InteractiveBackgroundResult) => void;
     runtimeSettings?: PraxisRuntimeSettings;
+    settingSources?: readonly ClaudeResourceScope[];
 }): Promise<number>;
 export {};
 //# sourceMappingURL=interactive.d.ts.map

package/dist/cli/interactive.js

@@ -12,6 +12,8 @@ import { claudePermissionActionKey, claudePermissionRuleMatches, } from '../perm
 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, 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';
 import { loadGitDiff, visiblePatchLines, } from './tui/git-diff.js';
 import { addTuiPermissionRule, loadTuiPermissionRules, removeTuiPermissionRule, } from './tui/permission-settings.js';
 import { createRecentlyDeniedStore, } from './tui/recently-denied.js';
@@ -245,7 +247,7 @@ const HIDDEN_TUI_SLASH_COMMANDS = new Set([
     'update',
     'usage',
 ]);
-export function InteractiveApp({ factory, initialSessions, initialPrompt, initialHistory = [], signal, onCancel, onTurnChange, onCleanup, onRendererChange, onBackground, axScreenReader = false, allowNewSession = true, resume, display = { version: 'dev', cwd: process.cwd() }, terminalWidth, slashCommands = EMPTY_SLASH_COMMANDS, agents = EMPTY_AGENTS, allowDangerouslySkipPermissions = false, additionalDirectories = [], diffLoader, fileLoader, externalEditor = editTuiPrompt, keybindingsConfigRoot, keybindingsFile = ensureTuiKeybindingsFile, keybindingsLoader = loadTuiKeybindings, keybindingsEditor = openTuiEditorFile, memoryFilesLoader = (configRoot, cwd) => loadTuiMemoryFiles({ configRoot, cwd }), memoryEditor = openTuiEditorFile, memoryFolderOpener = openTuiMemoryFolder, suspendProcess = suspendTuiProcess, clipboardReader = readTuiClipboard, clipboardWriter = writeTuiClipboard, sideQuestionClipboardWriter = writeTuiOsc52Clipboard, exportWriter = writeConversationExport, permissionRuleStore, sandboxStore: suppliedSandboxStore, recentlyDeniedStore: suppliedRecentlyDeniedStore, terminalSetup: terminalSetupOverride, themeStore, initialThemeSettings, initialThemeLoadError, workspaceDirectoryResolver = resolveTuiWorkspaceDirectory, workspaceDirectoryCompleter = completeTuiWorkspaceDirectory, runtimeSettings: suppliedRuntimeSettings, runtimeSettingsTarget, notificationWriter, elicitationUrlOpener = openTuiUrl, }) {
+export function InteractiveApp({ factory, initialSessions, initialPrompt, initialHistory = [], signal, onCancel, onTurnChange, onCleanup, onRendererChange, onBackground, axScreenReader = false, allowNewSession = true, resume, display = { version: 'dev', cwd: process.cwd() }, terminalWidth, slashCommands = EMPTY_SLASH_COMMANDS, agents = EMPTY_AGENTS, allowDangerouslySkipPermissions = false, additionalDirectories = [], diffLoader, fileLoader, externalEditor = editTuiPrompt, keybindingsConfigRoot, keybindingsFile = ensureTuiKeybindingsFile, keybindingsLoader = loadTuiKeybindings, keybindingsEditor = openTuiEditorFile, memoryFilesLoader = (configRoot, cwd) => loadTuiMemoryFiles({ configRoot, cwd }), memoryEditor = openTuiEditorFile, memoryFolderOpener = openTuiMemoryFolder, suspendProcess = suspendTuiProcess, clipboardReader = readTuiClipboard, clipboardWriter = writeTuiClipboard, sideQuestionClipboardWriter = writeTuiOsc52Clipboard, exportWriter = writeConversationExport, permissionRuleStore, sandboxStore: suppliedSandboxStore, recentlyDeniedStore: suppliedRecentlyDeniedStore, terminalSetup: terminalSetupOverride, themeStore, initialThemeSettings, initialThemeLoadError, workspaceDirectoryResolver = resolveTuiWorkspaceDirectory, workspaceDirectoryCompleter = completeTuiWorkspaceDirectory, runtimeSettings: suppliedRuntimeSettings, runtimeSettingsTarget, notificationWriter, elicitationUrlOpener = openTuiUrl, releaseNotesLoader = (configRoot) => loadClaudeReleaseNotes({ configRoot }), settingSources, }) {
     const { exit, suspendTerminal, waitUntilRenderFlush } = useApp();
     const width = useTerminalWidth(terminalWidth);
     const keybindingsRoot = useMemo(() => resolve(keybindingsConfigRoot ??
@@ -299,6 +301,7 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
     const [selectedIndex, setSelectedIndex] = useState(0);
     const selectedIndexRef = useRef(0);
     const [sessionId, setSessionId] = useState(resume?.sessionId ?? null);
+    const statusLineSessionId = useRef(resume?.sessionId ?? randomUUID());
     const sessionIdRef = useRef(resume?.sessionId ?? null);
     sessionIdRef.current = sessionId;
     const [sessionName, setSessionName] = useState(null);
@@ -4799,11 +4802,13 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
                 updateMenu({ kind: 'help', tabIndex: 0, selectedIndex: 0 });
             }
             else if (prompt === '/new') {
+                statusLineSessionId.current = randomUUID();
                 setSessionId(null);
                 setPendingFork(false);
                 append({ kind: 'notice', text: 'Started a new session.' });
             }
             else if (prompt === '/clear') {
+                statusLineSessionId.current = randomUUID();
                 setSessionId(null);
                 setPendingFork(false);
                 setHistory([]);
@@ -5176,6 +5181,27 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
             else if (prompt === '/status') {
                 openSettings('status');
             }
+            else if (prompt === '/release-notes') {
+                const loading = (async () => {
+                    setBusy(true);
+                    setStatus('loading release notes');
+                    try {
+                        append({
+                            kind: 'local-result',
+                            text: await releaseNotesLoader(keybindingsRoot),
+                        });
+                    }
+                    catch (error) {
+                        warn(error);
+                    }
+                    finally {
+                        setBusy(false);
+                        setStatus('ready');
+                    }
+                })();
+                onTurnChange?.(loading);
+                void loading.finally(() => onTurnChange?.(null));
+            }
             else if (prompt === '/config') {
                 openSettings('config');
             }
@@ -5395,7 +5421,39 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
                                     ? { prStatus: `PR #${activeSessionSummary.prNumber}` }
                                     : {}), shortcutsVisible: shortcutsVisible, ...(editorFooterMessage === undefined
                                     ? {}
-                                    : { footerMessage: editorFooterMessage }) })] }))] })) }) }));
+                                    : { footerMessage: editorFooterMessage }) }), _jsx(StatusLine, { configRoot: keybindingsRoot, cwd: runtimeCwd, input: createClaudeStatusLineInput({
+                                    configRoot: keybindingsRoot,
+                                    cwd: runtimeCwd,
+                                    projectDir: display.cwd,
+                                    sessionId: sessionId ?? statusLineSessionId.current,
+                                    sessionName,
+                                    ...(runtimeDisplay.model === undefined
+                                        ? {}
+                                        : { model: runtimeDisplay.model }),
+                                    version: runtimeDisplay.version,
+                                    outputStyle: runtimeSettings.outputStyle,
+                                    permissionMode: runtimePreferences.permissionMode,
+                                    additionalDirectories: runtimePreferences.additionalDirectories,
+                                    ...(usage === undefined ? {} : { usage }),
+                                    ...(costUsd === undefined ? {} : { costUsd }),
+                                    ...(runtimeDisplay.contextWindowTokens === undefined
+                                        ? {}
+                                        : {
+                                            contextWindowTokens: runtimeDisplay.contextWindowTokens,
+                                        }),
+                                    ...(runtimeSettings.editor === 'vim'
+                                        ? { vimMode: vimInsertMode ? 'INSERT' : 'NORMAL' }
+                                        : {}),
+                                }), refreshKey: [
+                                    history.length,
+                                    runtimePreferences.permissionMode,
+                                    runtimeDisplay.model,
+                                    runtimeSettings.outputStyle,
+                                    vimInsertMode,
+                                    sessionName,
+                                    usage?.inputTokens,
+                                    usage?.outputTokens,
+                                ].join(':'), ...(settingSources === undefined ? {} : { settingSources }) })] }))] })) }) }));
 }
 export async function runInteractive(options) {
     const controller = new AbortController();
@@ -5484,7 +5542,9 @@ export async function runInteractive(options) {
         let cleanup = null;
         let backgrounded;
         rendererChange = null;
-        const instance = render(_jsx(InteractiveApp, { factory: options.factory, initialSessions: initialSessions, slashCommands: initialSlashCommands, agents: initialAgents, initialHistory: history, runtimeSettings: currentRuntimeSettings, initialThemeSettings: initialThemeSettings, ...(initialThemeLoadError === undefined
+        const instance = render(_jsx(InteractiveApp, { factory: options.factory, initialSessions: initialSessions, slashCommands: initialSlashCommands, agents: initialAgents, initialHistory: history, runtimeSettings: currentRuntimeSettings, ...(options.settingSources === undefined
+                ? {}
+                : { settingSources: options.settingSources }), initialThemeSettings: initialThemeSettings, ...(initialThemeLoadError === undefined
                 ? {}
                 : { initialThemeLoadError }), ...(currentInitialPrompt === undefined
                 ? {}

package/dist/cli/tui/claude-command-inventory.d.ts

@@ -1,4 +1,4 @@
-export type ClaudeCommandDisposition = 'included' | 'excluded';
+export type ClaudeCommandDisposition = 'included' | 'deferred' | 'excluded';
 export type ClaudeCommandVisibility = 'visible' | 'hidden' | 'conditional';
 export interface ClaudeCommandInventoryEntry {
     name: string;
@@ -12,8 +12,9 @@ export declare const CLAUDE_2_1_208_COMMAND_INVENTORY: readonly [{
     readonly visibility: "visible";
 }, {
     readonly name: "advisor";
-    readonly disposition: "included";
+    readonly disposition: "deferred";
     readonly visibility: "conditional";
+    readonly reason: "Conditional advice mode is required parity work and is not implemented yet.";
 }, {
     readonly name: "agents";
     readonly disposition: "included";
@@ -28,17 +29,18 @@ export declare const CLAUDE_2_1_208_COMMAND_INVENTORY: readonly [{
     readonly visibility: "visible";
 }, {
     readonly name: "chrome";
-    readonly disposition: "excluded";
+    readonly disposition: "deferred";
     readonly visibility: "conditional";
-    readonly reason: "Chrome integration is outside the CLI-only product boundary.";
+    readonly reason: "The CLI-driven Chrome integration is required parity work and is not implemented yet.";
 }, {
     readonly name: "clear";
     readonly disposition: "included";
     readonly visibility: "visible";
 }, {
     readonly name: "color";
-    readonly disposition: "included";
+    readonly disposition: "deferred";
     readonly visibility: "visible";
+    readonly reason: "The dedicated /color contract is required; /theme is not a substitute.";
 }, {
     readonly name: "compact";
     readonly disposition: "included";
@@ -62,16 +64,18 @@ export declare const CLAUDE_2_1_208_COMMAND_INVENTORY: readonly [{
     readonly visibility: "conditional";
 }, {
     readonly name: "cost";
-    readonly disposition: "included";
+    readonly disposition: "deferred";
     readonly visibility: "conditional";
+    readonly reason: "The dedicated /cost contract is required; /status is not a substitute.";
 }, {
     readonly name: "diff";
     readonly disposition: "included";
     readonly visibility: "visible";
 }, {
     readonly name: "doctor";
-    readonly disposition: "included";
+    readonly disposition: "deferred";
     readonly visibility: "conditional";
+    readonly reason: "Interactive /doctor is required; the top-level command is not a substitute.";
 }, {
     readonly name: "effort";
     readonly disposition: "included";
@@ -82,8 +86,9 @@ export declare const CLAUDE_2_1_208_COMMAND_INVENTORY: readonly [{
     readonly visibility: "visible";
 }, {
     readonly name: "fast";
-    readonly disposition: "included";
+    readonly disposition: "deferred";
     readonly visibility: "conditional";
+    readonly reason: "The /fast state flow is required; model and effort controls are not a substitute.";
 }, {
     readonly name: "files";
     readonly disposition: "excluded";
@@ -91,8 +96,9 @@ export declare const CLAUDE_2_1_208_COMMAND_INVENTORY: readonly [{
     readonly reason: "The source command is restricted to the internal Ant user type.";
 }, {
     readonly name: "heapdump";
-    readonly disposition: "included";
+    readonly disposition: "deferred";
     readonly visibility: "hidden";
+    readonly reason: "The hidden heap-diagnostic contract is required parity work and is not implemented yet.";
 }, {
     readonly name: "help";
     readonly disposition: "included";
@@ -181,8 +187,9 @@ export declare const CLAUDE_2_1_208_COMMAND_INVENTORY: readonly [{
     readonly visibility: "visible";
 }, {
     readonly name: "stats";
-    readonly disposition: "included";
+    readonly disposition: "deferred";
     readonly visibility: "visible";
+    readonly reason: "Historical usage statistics are required parity work and are not implemented yet.";
 }, {
     readonly name: "status";
     readonly disposition: "included";
@@ -253,8 +260,9 @@ export declare const CLAUDE_2_1_208_COMMAND_INVENTORY: readonly [{
     readonly reason: "The source command is the Claude subscription plan-usage panel.";
 }, {
     readonly name: "insights";
-    readonly disposition: "included";
+    readonly disposition: "deferred";
     readonly visibility: "visible";
+    readonly reason: "Retrospective insights are required parity work and are not implemented yet.";
 }, {
     readonly name: "vim";
     readonly disposition: "included";
@@ -270,20 +278,24 @@ export declare const CLAUDE_2_1_208_COMMAND_INVENTORY: readonly [{
     readonly visibility: "conditional";
 }, {
     readonly name: "buddy";
-    readonly disposition: "included";
+    readonly disposition: "deferred";
     readonly visibility: "conditional";
+    readonly reason: "This conditional source mode is required parity work and is not implemented yet.";
 }, {
     readonly name: "proactive";
-    readonly disposition: "included";
+    readonly disposition: "deferred";
     readonly visibility: "conditional";
+    readonly reason: "This conditional source mode is required parity work and is not implemented yet.";
 }, {
     readonly name: "brief";
-    readonly disposition: "included";
+    readonly disposition: "deferred";
     readonly visibility: "conditional";
+    readonly reason: "This conditional source mode is required parity work and is not implemented yet.";
 }, {
     readonly name: "assistant";
-    readonly disposition: "included";
+    readonly disposition: "deferred";
     readonly visibility: "conditional";
+    readonly reason: "This conditional source mode is required parity work and is not implemented yet.";
 }, {
     readonly name: "remote-control";
     readonly disposition: "excluded";
@@ -296,16 +308,19 @@ export declare const CLAUDE_2_1_208_COMMAND_INVENTORY: readonly [{
     readonly reason: "Remote Control is outside the local-only boundary.";
 }, {
     readonly name: "voice";
-    readonly disposition: "included";
+    readonly disposition: "deferred";
     readonly visibility: "conditional";
+    readonly reason: "Conditional voice input is required parity work and is not implemented yet.";
 }, {
     readonly name: "think-back";
-    readonly disposition: "included";
+    readonly disposition: "deferred";
     readonly visibility: "conditional";
+    readonly reason: "The conditional retrospective flow is required parity work and is not implemented yet.";
 }, {
     readonly name: "thinkback-play";
-    readonly disposition: "included";
+    readonly disposition: "deferred";
     readonly visibility: "hidden";
+    readonly reason: "The hidden retrospective playback flow is required parity work and is not implemented yet.";
 }, {
     readonly name: "permissions";
     readonly disposition: "included";
@@ -361,8 +376,9 @@ export declare const CLAUDE_2_1_208_COMMAND_INVENTORY: readonly [{
     readonly visibility: "conditional";
 }, {
     readonly name: "torch";
-    readonly disposition: "included";
+    readonly disposition: "deferred";
     readonly visibility: "conditional";
+    readonly reason: "This source-gated behavior is required conditional parity work and is not implemented yet.";
 }];
 export declare const CLAUDE_2_1_208_COMMAND_BY_NAME: ReadonlyMap<string, ClaudeCommandInventoryEntry>;
 //# sourceMappingURL=claude-command-inventory.d.ts.map

package/dist/cli/tui/claude-command-inventory.js

@@ -4,18 +4,28 @@
 // disappearing from the parity inventory.
 export const CLAUDE_2_1_208_COMMAND_INVENTORY = [
     { name: 'add-dir', disposition: 'included', visibility: 'visible' },
-    { name: 'advisor', disposition: 'included', visibility: 'conditional' },
+    {
+        name: 'advisor',
+        disposition: 'deferred',
+        visibility: 'conditional',
+        reason: 'Conditional advice mode is required parity work and is not implemented yet.',
+    },
     { name: 'agents', disposition: 'included', visibility: 'visible' },
     { name: 'branch', disposition: 'included', visibility: 'visible' },
     { name: 'btw', disposition: 'included', visibility: 'visible' },
     {
         name: 'chrome',
-        disposition: 'excluded',
+        disposition: 'deferred',
         visibility: 'conditional',
-        reason: 'Chrome integration is outside the CLI-only product boundary.',
+        reason: 'The CLI-driven Chrome integration is required parity work and is not implemented yet.',
     },
     { name: 'clear', disposition: 'included', visibility: 'visible' },
-    { name: 'color', disposition: 'included', visibility: 'visible' },
+    {
+        name: 'color',
+        disposition: 'deferred',
+        visibility: 'visible',
+        reason: 'The dedicated /color contract is required; /theme is not a substitute.',
+    },
     { name: 'compact', disposition: 'included', visibility: 'visible' },
     { name: 'config', disposition: 'included', visibility: 'visible' },
     { name: 'copy', disposition: 'included', visibility: 'visible' },
@@ -26,19 +36,39 @@ export const CLAUDE_2_1_208_COMMAND_INVENTORY = [
         reason: 'Desktop handoff/import is outside the CLI-only product boundary.',
     },
     { name: 'context', disposition: 'included', visibility: 'conditional' },
-    { name: 'cost', disposition: 'included', visibility: 'conditional' },
+    {
+        name: 'cost',
+        disposition: 'deferred',
+        visibility: 'conditional',
+        reason: 'The dedicated /cost contract is required; /status is not a substitute.',
+    },
     { name: 'diff', disposition: 'included', visibility: 'visible' },
-    { name: 'doctor', disposition: 'included', visibility: 'conditional' },
+    {
+        name: 'doctor',
+        disposition: 'deferred',
+        visibility: 'conditional',
+        reason: 'Interactive /doctor is required; the top-level command is not a substitute.',
+    },
     { name: 'effort', disposition: 'included', visibility: 'visible' },
     { name: 'exit', disposition: 'included', visibility: 'visible' },
-    { name: 'fast', disposition: 'included', visibility: 'conditional' },
+    {
+        name: 'fast',
+        disposition: 'deferred',
+        visibility: 'conditional',
+        reason: 'The /fast state flow is required; model and effort controls are not a substitute.',
+    },
     {
         name: 'files',
         disposition: 'excluded',
         visibility: 'conditional',
         reason: 'The source command is restricted to the internal Ant user type.',
     },
-    { name: 'heapdump', disposition: 'included', visibility: 'hidden' },
+    {
+        name: 'heapdump',
+        disposition: 'deferred',
+        visibility: 'hidden',
+        reason: 'The hidden heap-diagnostic contract is required parity work and is not implemented yet.',
+    },
     { name: 'help', disposition: 'included', visibility: 'visible' },
     {
         name: 'ide',
@@ -89,7 +119,12 @@ export const CLAUDE_2_1_208_COMMAND_INVENTORY = [
         reason: 'Remote-session URLs and QR codes are outside the local-only boundary.',
     },
     { name: 'skills', disposition: 'included', visibility: 'visible' },
-    { name: 'stats', disposition: 'included', visibility: 'visible' },
+    {
+        name: 'stats',
+        disposition: 'deferred',
+        visibility: 'visible',
+        reason: 'Historical usage statistics are required parity work and are not implemented yet.',
+    },
     { name: 'status', disposition: 'included', visibility: 'visible' },
     { name: 'statusline', disposition: 'included', visibility: 'visible' },
     {
@@ -149,7 +184,12 @@ export const CLAUDE_2_1_208_COMMAND_INVENTORY = [
         visibility: 'conditional',
         reason: 'The source command is the Claude subscription plan-usage panel.',
     },
-    { name: 'insights', disposition: 'included', visibility: 'visible' },
+    {
+        name: 'insights',
+        disposition: 'deferred',
+        visibility: 'visible',
+        reason: 'Retrospective insights are required parity work and are not implemented yet.',
+    },
     { name: 'vim', disposition: 'included', visibility: 'visible' },
     {
         name: 'web-setup',
@@ -158,10 +198,30 @@ export const CLAUDE_2_1_208_COMMAND_INVENTORY = [
         reason: 'Remote setup is outside the local-only boundary.',
     },
     { name: 'fork', disposition: 'included', visibility: 'conditional' },
-    { name: 'buddy', disposition: 'included', visibility: 'conditional' },
-    { name: 'proactive', disposition: 'included', visibility: 'conditional' },
-    { name: 'brief', disposition: 'included', visibility: 'conditional' },
-    { name: 'assistant', disposition: 'included', visibility: 'conditional' },
+    {
+        name: 'buddy',
+        disposition: 'deferred',
+        visibility: 'conditional',
+        reason: 'This conditional source mode is required parity work and is not implemented yet.',
+    },
+    {
+        name: 'proactive',
+        disposition: 'deferred',
+        visibility: 'conditional',
+        reason: 'This conditional source mode is required parity work and is not implemented yet.',
+    },
+    {
+        name: 'brief',
+        disposition: 'deferred',
+        visibility: 'conditional',
+        reason: 'This conditional source mode is required parity work and is not implemented yet.',
+    },
+    {
+        name: 'assistant',
+        disposition: 'deferred',
+        visibility: 'conditional',
+        reason: 'This conditional source mode is required parity work and is not implemented yet.',
+    },
     {
         name: 'remote-control',
         disposition: 'excluded',
@@ -174,9 +234,24 @@ export const CLAUDE_2_1_208_COMMAND_INVENTORY = [
         visibility: 'conditional',
         reason: 'Remote Control is outside the local-only boundary.',
     },
-    { name: 'voice', disposition: 'included', visibility: 'conditional' },
-    { name: 'think-back', disposition: 'included', visibility: 'conditional' },
-    { name: 'thinkback-play', disposition: 'included', visibility: 'hidden' },
+    {
+        name: 'voice',
+        disposition: 'deferred',
+        visibility: 'conditional',
+        reason: 'Conditional voice input is required parity work and is not implemented yet.',
+    },
+    {
+        name: 'think-back',
+        disposition: 'deferred',
+        visibility: 'conditional',
+        reason: 'The conditional retrospective flow is required parity work and is not implemented yet.',
+    },
+    {
+        name: 'thinkback-play',
+        disposition: 'deferred',
+        visibility: 'hidden',
+        reason: 'The hidden retrospective playback flow is required parity work and is not implemented yet.',
+    },
     { name: 'permissions', disposition: 'included', visibility: 'visible' },
     { name: 'plan', disposition: 'included', visibility: 'visible' },
     {
@@ -214,7 +289,12 @@ export const CLAUDE_2_1_208_COMMAND_INVENTORY = [
     },
     { name: 'tasks', disposition: 'included', visibility: 'visible' },
     { name: 'workflows', disposition: 'included', visibility: 'conditional' },
-    { name: 'torch', disposition: 'included', visibility: 'conditional' },
+    {
+        name: 'torch',
+        disposition: 'deferred',
+        visibility: 'conditional',
+        reason: 'This source-gated behavior is required conditional parity work and is not implemented yet.',
+    },
 ];
 export const CLAUDE_2_1_208_COMMAND_BY_NAME = new Map(CLAUDE_2_1_208_COMMAND_INVENTORY.map((entry) => [entry.name, entry]));
 //# sourceMappingURL=claude-command-inventory.js.map

package/dist/cli/tui/release-notes.d.ts

@@ -0,0 +1,10 @@
+export declare const CLAUDE_CHANGELOG_URL = "https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md";
+export interface ReleaseNotesOptions {
+    configRoot: string;
+    fetcher?: typeof fetch;
+    timeoutMs?: number;
+}
+export declare function parseClaudeChangelog(content: string): readonly [version: string, notes: readonly string[]][];
+export declare function formatClaudeReleaseNotes(content: string): string | null;
+export declare function loadClaudeReleaseNotes({ configRoot, fetcher, timeoutMs, }: ReleaseNotesOptions): Promise<string>;
+//# sourceMappingURL=release-notes.d.ts.map

package/dist/cli/tui/release-notes.js

@@ -0,0 +1,60 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+export const CLAUDE_CHANGELOG_URL = 'https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md';
+const CLAUDE_RAW_CHANGELOG_URL = 'https://raw.githubusercontent.com/anthropics/claude-code/refs/heads/main/CHANGELOG.md';
+export function parseClaudeChangelog(content) {
+    const releases = [];
+    for (const section of content.split(/^## /gmu).slice(1)) {
+        const [heading, ...lines] = section.trim().split(/\r?\n/u);
+        const version = heading?.split(' - ')[0]?.trim();
+        if (!version)
+            continue;
+        const notes = lines
+            .map((line) => line.trim())
+            .filter((line) => line.startsWith('- '))
+            .map((line) => line.slice(2).trim())
+            .filter(Boolean);
+        if (notes.length > 0)
+            releases.push([version, notes]);
+    }
+    return releases.sort(([left], [right]) => left.localeCompare(right, undefined, { numeric: true }));
+}
+export function formatClaudeReleaseNotes(content) {
+    const releases = parseClaudeChangelog(content);
+    if (releases.length === 0)
+        return null;
+    return releases
+        .map(([version, notes]) => `Version ${version}:\n${notes.map((note) => `· ${note}`).join('\n')}`)
+        .join('\n\n');
+}
+async function cachedChangelog(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return '';
+        throw error;
+    }
+}
+export async function loadClaudeReleaseNotes({ configRoot, fetcher = fetch, timeoutMs = 500, }) {
+    const cachePath = join(configRoot, 'cache', 'changelog.md');
+    let fresh = '';
+    try {
+        const response = await fetcher(CLAUDE_RAW_CHANGELOG_URL, {
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (response.ok) {
+            fresh = await response.text();
+            await mkdir(dirname(cachePath), { recursive: true });
+            await writeFile(cachePath, fresh, 'utf8');
+        }
+    }
+    catch {
+        // A release-notes lookup is best-effort; the shared cache is authoritative
+        // whenever the network is unavailable or slower than the UI budget.
+    }
+    const formatted = formatClaudeReleaseNotes(fresh || (await cachedChangelog(cachePath)));
+    return formatted ?? `See the full changelog at: ${CLAUDE_CHANGELOG_URL}`;
+}
+//# sourceMappingURL=release-notes.js.map

package/dist/cli/tui/slash-commands.js

@@ -124,6 +124,11 @@ export const BUILTIN_TUI_SLASH_COMMANDS = [
         description: 'Activate pending plugin changes in the current session',
         source: 'builtin',
     },
+    {
+        name: 'release-notes',
+        description: 'View release notes',
+        source: 'builtin',
+    },
     {
         name: 'rename',
         description: 'Rename the current conversation',

package/dist/cli/tui/status-line.d.ts

@@ -0,0 +1,88 @@
+import type { ClaudeResourceScope } from '../../compatibility/claude/shared-resources.js';
+import type { ModelUsage } from '../../core/runtime.js';
+export interface ClaudeStatusLineSetting {
+    type: 'command';
+    command: string;
+    padding?: number;
+}
+export interface ClaudeStatusLineInput {
+    session_id: string;
+    session_name?: string;
+    transcript_path: string;
+    cwd: string;
+    permission_mode?: string;
+    model: {
+        id: string;
+        display_name: string;
+    };
+    workspace: {
+        current_dir: string;
+        project_dir: string;
+        added_dirs: readonly string[];
+    };
+    version: string;
+    output_style: {
+        name: string;
+    };
+    cost: {
+        total_cost_usd: number;
+        total_duration_ms: number;
+        total_api_duration_ms: number;
+        total_lines_added: number;
+        total_lines_removed: number;
+    };
+    context_window: {
+        total_input_tokens: number;
+        total_output_tokens: number;
+        context_window_size: number;
+        current_usage: {
+            input_tokens: number;
+            output_tokens: number;
+            cache_creation_input_tokens: number;
+            cache_read_input_tokens: number;
+        } | null;
+        used_percentage: number | null;
+        remaining_percentage: number | null;
+    };
+    exceeds_200k_tokens: boolean;
+    vim?: {
+        mode: 'INSERT' | 'NORMAL';
+    };
+}
+export declare function loadClaudeStatusLineSetting(options: {
+    configRoot: string;
+    cwd: string;
+    settingSources?: readonly ClaudeResourceScope[];
+}): Promise<{
+    setting?: ClaudeStatusLineSetting;
+    disabled: boolean;
+}>;
+export declare function executeClaudeStatusLine(setting: ClaudeStatusLineSetting, input: ClaudeStatusLineInput, options?: {
+    cwd: string;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}): Promise<string | undefined>;
+export declare function createClaudeStatusLineInput(options: {
+    configRoot: string;
+    cwd: string;
+    projectDir: string;
+    sessionId: string;
+    sessionName?: string | null;
+    model?: string;
+    version: string;
+    outputStyle: string;
+    permissionMode?: string;
+    additionalDirectories: readonly string[];
+    usage?: ModelUsage;
+    costUsd?: number;
+    contextWindowTokens?: number;
+    vimMode?: 'INSERT' | 'NORMAL';
+}): ClaudeStatusLineInput;
+export declare function StatusLine({ configRoot, cwd, input, refreshKey, settingSources, }: {
+    configRoot: string;
+    cwd: string;
+    input: ClaudeStatusLineInput;
+    refreshKey: string;
+    settingSources?: readonly ClaudeResourceScope[];
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=status-line.d.ts.map

package/dist/cli/tui/status-line.js

@@ -0,0 +1,234 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { spawn } from 'node:child_process';
+import { watchFile, unwatchFile } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { Box, Text } from 'ink';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { isClaudeSessionId, resolveClaudePaths, sanitizeClaudeProjectPath, } from '../../compatibility/claude/paths.js';
+import { loadClaudeSettings } from '../../compatibility/claude/shared-resources.js';
+import { commandShell, commandShellArguments, } from '../../platform/command-shell.js';
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+export async function loadClaudeStatusLineSetting(options) {
+    const resources = await loadClaudeSettings(options);
+    const merged = Object.assign({}, ...resources.map((resource) => record(resource.value) ?? {}));
+    const value = record(merged.statusLine);
+    const setting = value?.type === 'command' && typeof value.command === 'string'
+        ? {
+            type: 'command',
+            command: value.command,
+            ...(typeof value.padding === 'number' &&
+                Number.isFinite(value.padding)
+                ? { padding: value.padding }
+                : {}),
+        }
+        : undefined;
+    return {
+        ...(setting ? { setting } : {}),
+        disabled: merged.disableAllHooks === true,
+    };
+}
+export async function executeClaudeStatusLine(setting, input, options = {
+    cwd: process.cwd(),
+}) {
+    const timeout = AbortSignal.timeout(options.timeoutMs ?? 5000);
+    const signal = options.signal
+        ? AbortSignal.any([options.signal, timeout])
+        : timeout;
+    return new Promise((resolve) => {
+        let settled = false;
+        let stdout = '';
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(value);
+        };
+        let child;
+        try {
+            child = spawn(commandShell(), commandShellArguments(setting.command), {
+                cwd: options.cwd,
+                detached: process.platform !== 'win32',
+                env: process.env,
+                stdio: ['pipe', 'pipe', 'ignore'],
+            });
+        }
+        catch {
+            finish();
+            return;
+        }
+        child.stdout.setEncoding('utf8');
+        const terminate = () => {
+            if (child.pid === undefined)
+                return;
+            try {
+                if (process.platform === 'win32')
+                    child.kill('SIGKILL');
+                else
+                    process.kill(-child.pid, 'SIGKILL');
+            }
+            catch (error) {
+                if (error.code !== 'ESRCH')
+                    finish();
+            }
+        };
+        if (signal.aborted)
+            terminate();
+        else
+            signal.addEventListener('abort', terminate, { once: true });
+        child.stdout.on('data', (chunk) => {
+            if (stdout.length <= 1024 * 1024)
+                stdout += chunk;
+        });
+        child.on('error', () => {
+            signal.removeEventListener('abort', terminate);
+            finish();
+        });
+        child.on('close', (code) => {
+            signal.removeEventListener('abort', terminate);
+            if (code !== 0 || signal.aborted) {
+                finish();
+                return;
+            }
+            const output = stdout
+                .trim()
+                .split(/\r?\n/u)
+                .map((line) => line.trim())
+                .filter(Boolean)
+                .join('\n');
+            finish(output || undefined);
+        });
+        child.stdin.on('error', () => undefined);
+        child.stdin.end(JSON.stringify(input));
+    });
+}
+export function createClaudeStatusLineInput(options) {
+    const usage = options.usage;
+    const contextInputTokens = usage
+        ? usage.inputTokens +
+            (usage.cacheReadInputTokens ?? 0) +
+            (usage.cacheCreationInputTokens ?? 0)
+        : null;
+    const usedTokens = contextInputTokens === null || usage === undefined
+        ? null
+        : contextInputTokens + usage.outputTokens;
+    const contextWindowSize = options.contextWindowTokens ?? 0;
+    const usedPercentage = contextInputTokens === null || contextWindowSize <= 0
+        ? null
+        : Math.min(100, Math.max(0, Math.round((contextInputTokens / contextWindowSize) * 100)));
+    const model = options.model ?? 'default';
+    const transcriptPath = isClaudeSessionId(options.sessionId)
+        ? resolveClaudePaths({
+            configDir: options.configRoot,
+            cwd: options.cwd,
+            sessionId: options.sessionId,
+        }).sessionFile
+        : resolve(options.configRoot, 'projects', sanitizeClaudeProjectPath(options.cwd), `${options.sessionId}.jsonl`);
+    return {
+        session_id: options.sessionId,
+        ...(options.sessionName ? { session_name: options.sessionName } : {}),
+        transcript_path: transcriptPath,
+        cwd: options.cwd,
+        ...(options.permissionMode
+            ? { permission_mode: options.permissionMode }
+            : {}),
+        model: { id: model, display_name: model },
+        workspace: {
+            current_dir: options.cwd,
+            project_dir: options.projectDir,
+            added_dirs: options.additionalDirectories,
+        },
+        version: options.version,
+        output_style: { name: options.outputStyle },
+        cost: {
+            total_cost_usd: options.costUsd ?? 0,
+            total_duration_ms: 0,
+            total_api_duration_ms: 0,
+            total_lines_added: 0,
+            total_lines_removed: 0,
+        },
+        context_window: {
+            total_input_tokens: usage?.inputTokens ?? 0,
+            total_output_tokens: usage?.outputTokens ?? 0,
+            context_window_size: contextWindowSize,
+            current_usage: usage
+                ? {
+                    input_tokens: usage.inputTokens,
+                    output_tokens: usage.outputTokens,
+                    cache_creation_input_tokens: usage.cacheCreationInputTokens ?? 0,
+                    cache_read_input_tokens: usage.cacheReadInputTokens ?? 0,
+                }
+                : null,
+            used_percentage: usedPercentage,
+            remaining_percentage: usedPercentage === null ? null : 100 - usedPercentage,
+        },
+        exceeds_200k_tokens: usedTokens !== null && usedTokens > 200_000,
+        ...(options.vimMode ? { vim: { mode: options.vimMode } } : {}),
+    };
+}
+export function StatusLine({ configRoot, cwd, input, refreshKey, settingSources, }) {
+    const [text, setText] = useState();
+    const [padding, setPadding] = useState(0);
+    const timer = useRef(undefined);
+    const controller = useRef(undefined);
+    const latestInput = useRef(input);
+    latestInput.current = input;
+    const update = useCallback(async () => {
+        controller.current?.abort();
+        const current = new AbortController();
+        controller.current = current;
+        try {
+            const loaded = await loadClaudeStatusLineSetting({
+                configRoot,
+                cwd,
+                ...(settingSources === undefined ? {} : { settingSources }),
+            });
+            if (current.signal.aborted)
+                return;
+            setPadding(loaded.setting?.padding ?? 0);
+            if (loaded.disabled || !loaded.setting) {
+                setText(undefined);
+                return;
+            }
+            const result = await executeClaudeStatusLine(loaded.setting, latestInput.current, { cwd, signal: current.signal });
+            if (!current.signal.aborted)
+                setText(result);
+        }
+        catch {
+            if (!current.signal.aborted)
+                setText(undefined);
+        }
+    }, [configRoot, cwd, settingSources]);
+    const schedule = useCallback(() => {
+        if (timer.current)
+            clearTimeout(timer.current);
+        timer.current = setTimeout(() => void update(), 300);
+    }, [update]);
+    useEffect(() => {
+        schedule();
+    }, [refreshKey, schedule]);
+    useEffect(() => {
+        const paths = [
+            join(configRoot, 'settings.json'),
+            join(cwd, '.claude', 'settings.json'),
+            join(cwd, '.claude', 'settings.local.json'),
+        ];
+        const changed = () => schedule();
+        for (const path of paths)
+            watchFile(path, { interval: 500 }, changed);
+        return () => {
+            for (const path of paths)
+                unwatchFile(path, changed);
+            controller.current?.abort();
+            if (timer.current)
+                clearTimeout(timer.current);
+        };
+    }, [configRoot, cwd, schedule]);
+    if (!text)
+        return null;
+    return (_jsx(Box, { paddingX: padding, children: _jsx(Text, { dimColor: true, wrap: "truncate", children: text }) }));
+}
+//# sourceMappingURL=status-line.js.map

package/dist/cli.d.ts

@@ -96,6 +96,7 @@ interface TopLevelAgentCommands {
     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>;
     createService(options: {
         eventSink: RuntimeEventSink;
         requireProvider: boolean;

package/dist/cli.js

@@ -14,6 +14,7 @@ import { isClaudeSessionId, resolveClaudePaths, } from './compatibility/claude/p
 import { loadClaudeContextResources, loadClaudeSettings, loadClaudeSharedResources, resolveClaudeProjectMemoryDirectory, } from './compatibility/claude/shared-resources.js';
 import { AgentRunCancelledError, } from './core/runtime.js';
 import { persistTuiPermissionUpdates } from './cli/tui/permission-settings.js';
+import { loadClaudeReleaseNotes } from './cli/tui/release-notes.js';
 import { projectTuiHooks, } from './cli/tui/hook-settings.js';
 import { DEFAULT_CLI_CONTROLS, resolveCliControls } from './cli/controls.js';
 import { applyRuntimeSettingDefaults, loadRuntimeSettings, runtimeSettingsSystemPrompt, } from './cli/tui/runtime-settings.js';
@@ -1609,6 +1610,9 @@ const defaultDependencies = {
                 ? { allowDangerouslySkipPermissions: true }
                 : {}),
             additionalDirectories: initialAdditionalDirectories,
+            ...(interactiveControls.settingSources === undefined
+                ? {}
+                : { settingSources: interactiveControls.settingSources }),
             display: {
                 version: VERSION,
                 cwd: process.cwd(),
@@ -3856,6 +3860,48 @@ async function execute(argv, io, dependencies, signal) {
                 : {}),
         };
     };
+    const headlessPromptArgs = command === 'resume' ? args.slice(2) : knownCommand ? args.slice(1) : args;
+    const headlessPrompt = inputFormat === 'text' && headlessPromptArgs.length > 0
+        ? promptFrom(headlessPromptArgs)
+        : undefined;
+    if (headlessPrompt === '/release-notes' && !invocation.disableSlashCommands) {
+        const startedAt = Date.now();
+        const sessionId = invocation.sessionId ?? randomUUID();
+        const configRoot = resolve(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude'));
+        const text = dependencies.loadReleaseNotes
+            ? await dependencies.loadReleaseNotes(configRoot)
+            : await loadClaudeReleaseNotes({ configRoot });
+        const result = {
+            sessionId,
+            text,
+            usage: { inputTokens: 0, outputTokens: 0 },
+        };
+        const info = {
+            cwd: process.cwd(),
+            model: invocation.model ?? process.env.PRAXIS_MODEL ?? 'unknown',
+            tools: [],
+            mcpServers: [],
+            permissionMode: invocation.permissionMode,
+            slashCommands: ['release-notes'],
+            agents: [],
+            skills: [],
+            claudeCodeVersion: '2.1.208',
+        };
+        if (outputFormat === 'stream-json') {
+            const output = new StreamJsonOutput((value) => writeJson(io, value), info, sessionId, includePartialMessages, invocation.includeHookEvents);
+            output.init();
+            output.sink({ type: 'text-delta', delta: text });
+            output.sink({ type: 'usage', usage: result.usage });
+            output.result(result, startedAt);
+        }
+        else if (outputFormat === 'json' || invocation.legacyJson) {
+            writeJson(io, createSuccessResult(result, info, startedAt, 0));
+        }
+        else {
+            io.stdout(`${text}\n`);
+        }
+        return 0;
+    }
     const service = await dependencies.createService({
         eventSink: outputFormat === 'stream-json' && !invocation.legacyJson
             ? (event) => {

package/dist/extensions/claude-extensions.d.ts

@@ -28,6 +28,7 @@ export interface ClaudePromptExpansionMessage {
     contentBlocks?: readonly ModelContentBlock[];
     images?: readonly ModelImage[];
 }
+export declare const BUILTIN_STATUSLINE_AGENT_PATH = "/__praxis_builtin__/agents/statusline-setup.md";
 export declare function validateClaudeExtensions(resources: readonly ClaudeTextResource[]): void;
 export declare class ClaudeExtensionCatalog {
     private readonly commands;

package/dist/extensions/claude-extensions.js

@@ -34,6 +34,49 @@ Call CronCreate with the derived cron, the parsed prompt verbatim, and recurring
 Input:
 $ARGUMENTS`,
 };
+const BUILTIN_STATUSLINE_COMMAND = {
+    path: '/__praxis_builtin__/commands/statusline.md',
+    scope: 'user',
+    content: '',
+    kind: 'command',
+    name: 'statusline',
+    description: "Set up Claude Code's status line UI",
+    modelInvocable: true,
+    permissionSafe: true,
+    body: `Create an Agent with subagent_type "statusline-setup" and the prompt "$ARGUMENTS"`,
+};
+export const BUILTIN_STATUSLINE_AGENT_PATH = '/__praxis_builtin__/agents/statusline-setup.md';
+const BUILTIN_STATUSLINE_AGENT = {
+    path: BUILTIN_STATUSLINE_AGENT_PATH,
+    scope: 'user',
+    content: '',
+    kind: 'agent',
+    name: 'statusline-setup',
+    description: "Configure the user's Claude Code status line setting.",
+    modelInvocable: false,
+    permissionSafe: false,
+    body: `You configure the statusLine command in the user's shared Claude Code settings.
+
+Importing a shell prompt:
+1. Inspect shell configuration in this order: ~/.zshrc, ~/.bashrc, ~/.bash_profile, then ~/.profile.
+2. Find an exported or unexported quoted PS1 assignment. Preserve the prompt's information and colors.
+3. Translate prompt escapes into commands: user to $(whoami), short/full host to $(hostname -s)/$(hostname), working directory to $(pwd), basename to $(basename "$(pwd)"), and time/date escapes to the corresponding date command. Preserve newlines and literal prompt counters.
+4. Emit ANSI sequences with printf because the result is rendered by a terminal in dimmed colors.
+5. Remove a trailing prompt marker such as "$" or ">" from the displayed status line.
+6. If no PS1 exists and the request gives no other design, ask what information should be displayed.
+
+The status command receives one JSON document on stdin. It contains session_id, optional session_name, transcript_path, cwd, model.id and model.display_name, workspace.current_dir/project_dir/added_dirs, version, output_style.name, cost totals, context_window totals/current_usage/used_percentage/remaining_percentage, exceeds_200k_tokens, and optional vim, agent, and worktree objects. Read stdin once and reuse it when extracting multiple values. Typical jq selectors include .model.display_name, .workspace.current_dir, .output_style.name, .context_window.remaining_percentage, and .context_window.used_percentage. Optional values must be tested before printing them.
+
+Preserve every unrelated setting and update ~/.claude/settings.json with this shape:
+{
+  "statusLine": {
+    "type": "command",
+    "command": "the command"
+  }
+}
+
+Resolve a symlinked settings file and edit its target. Complex implementations may live in a script under ~/.claude and be referenced by the setting. Git commands in that script must avoid optional locks. Report the exact configuration and script path, if any. End by telling the parent agent that future status-line changes must use the statusline-setup agent and that the user can request further changes.`,
+};
 const GENERAL_PURPOSE_AGENT = {
     name: 'general-purpose',
     description: 'General-purpose agent for researching complex questions, searching for code, and executing multi-step tasks.',
@@ -175,7 +218,10 @@ export class ClaudeExtensionCatalog {
         this.disableSlashCommands = options.disableSlashCommands === true;
         this.commands = options.disableSlashCommands
             ? new Map()
-            : new Map([['loop', BUILTIN_LOOP]]);
+            : new Map([
+                ['loop', BUILTIN_LOOP],
+                ['statusline', BUILTIN_STATUSLINE_COMMAND],
+            ]);
         if (!options.disableSlashCommands) {
             for (const [name, command] of indexed('command', resources.commands)) {
                 this.commands.set(name, command);
@@ -184,7 +230,10 @@ export class ClaudeExtensionCatalog {
         this.skills = options.disableSlashCommands
             ? new Map()
             : indexed('skill', resources.skills);
-        this.agents = indexed('agent', resources.agents);
+        this.agents = new Map([
+            ['statusline-setup', BUILTIN_STATUSLINE_AGENT],
+            ...indexed('agent', resources.agents),
+        ]);
     }
     setMcpPrompts(prompts) {
         this.mcpPrompts.clear();
@@ -208,6 +257,9 @@ export class ClaudeExtensionCatalog {
         if (!definition) {
             return { userMessages: [prompt] };
         }
+        const invocationArguments = definition === BUILTIN_STATUSLINE_COMMAND && argumentsText.length === 0
+            ? 'Configure my statusLine from my shell PS1 configuration'
+            : argumentsText;
         return {
             userMessages: [
                 [
@@ -217,7 +269,7 @@ export class ClaudeExtensionCatalog {
                         ? [`<command-args>${argumentsText}</command-args>`]
                         : []),
                 ].join('\n'),
-                renderInvocation(definition, argumentsText),
+                renderInvocation(definition, invocationArguments),
             ],
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-agent",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",