praxis-agent 0.12.0 → 0.14.0

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.d.ts

@@ -3,6 +3,7 @@ export interface TuiSlashCommand {
     name: string;
     description: string;
     source: TuiSlashCommandSource;
+    progressMessage?: string;
 }
 export declare const BUILTIN_TUI_SLASH_COMMANDS: readonly TuiSlashCommand[];
 export declare function mergeTuiSlashCommands(commands: readonly TuiSlashCommand[]): readonly TuiSlashCommand[];

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';
@@ -1358,7 +1359,10 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             slashCommands: () => extensions.slashCommandDefinitions().map((definition) => ({
                 name: definition.name,
                 description: definition.description,
-                source: definition.kind,
+                source: definition.builtin === true ? 'builtin' : definition.kind,
+                ...(definition.progressMessage === undefined
+                    ? {}
+                    : { progressMessage: definition.progressMessage }),
             })),
             hookConfiguration: async () => projectTuiHooks(settings),
             mcpInspect: () => service.mcpInspect(),
@@ -1609,6 +1613,9 @@ const defaultDependencies = {
                 ? { allowDangerouslySkipPermissions: true }
                 : {}),
             additionalDirectories: initialAdditionalDirectories,
+            ...(interactiveControls.settingSources === undefined
+                ? {}
+                : { settingSources: interactiveControls.settingSources }),
             display: {
                 version: VERSION,
                 cwd: process.cwd(),
@@ -3856,6 +3863,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

@@ -9,11 +9,15 @@ export interface ClaudeExtensionDefinition extends ClaudeTextResource {
     body: string;
     modelInvocable: boolean;
     permissionSafe: boolean;
+    progressMessage?: string;
+    builtin?: boolean;
 }
 export interface ClaudeSlashCommandDefinition {
     name: string;
     description: string;
     kind: 'command' | 'skill' | 'mcp';
+    progressMessage?: string;
+    builtin?: boolean;
 }
 export interface ClaudeAgentDefinition {
     name: string;
@@ -28,6 +32,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

@@ -1,5 +1,6 @@
 import { basename, dirname, extname } from 'node:path';
 import { parse as parseYaml } from 'yaml';
+import { claudeInitDescription, claudeInitPrompt, } from './claude-init-command.js';
 const BUILTIN_LOOP = {
     path: '/__praxis_builtin__/commands/loop.md',
     scope: 'user',
@@ -9,6 +10,7 @@ const BUILTIN_LOOP = {
     description: 'Run a prompt or slash command on a recurring interval; defaults to 10 minutes.',
     modelInvocable: true,
     permissionSafe: true,
+    builtin: true,
     body: `# /loop — schedule a recurring prompt
 
 Parse the input into an optional interval followed by a prompt, then schedule it with CronCreate.
@@ -34,6 +36,65 @@ Call CronCreate with the derived cron, the parsed prompt verbatim, and recurring
 Input:
 $ARGUMENTS`,
 };
+function builtinInitCommand() {
+    return {
+        path: '/__praxis_builtin__/commands/init.md',
+        scope: 'user',
+        content: '',
+        kind: 'command',
+        name: 'init',
+        description: claudeInitDescription(),
+        modelInvocable: false,
+        permissionSafe: true,
+        progressMessage: 'analyzing your codebase',
+        builtin: true,
+        body: claudeInitPrompt(),
+    };
+}
+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: false,
+    permissionSafe: true,
+    builtin: 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 +236,11 @@ export class ClaudeExtensionCatalog {
         this.disableSlashCommands = options.disableSlashCommands === true;
         this.commands = options.disableSlashCommands
             ? new Map()
-            : new Map([['loop', BUILTIN_LOOP]]);
+            : new Map([
+                ['loop', BUILTIN_LOOP],
+                ['init', builtinInitCommand()],
+                ['statusline', BUILTIN_STATUSLINE_COMMAND],
+            ]);
         if (!options.disableSlashCommands) {
             for (const [name, command] of indexed('command', resources.commands)) {
                 this.commands.set(name, command);
@@ -184,7 +249,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 +276,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 +288,7 @@ export class ClaudeExtensionCatalog {
                         ? [`<command-args>${argumentsText}</command-args>`]
                         : []),
                 ].join('\n'),
-                renderInvocation(definition, argumentsText),
+                renderInvocation(definition, invocationArguments),
             ],
         };
     }
@@ -270,6 +341,10 @@ export class ClaudeExtensionCatalog {
                 name: definition.name,
                 description: definition.description,
                 kind: definition.kind === 'skill' ? 'skill' : 'command',
+                ...(definition.progressMessage === undefined
+                    ? {}
+                    : { progressMessage: definition.progressMessage }),
+                ...(definition.builtin === true ? { builtin: true } : {}),
             })),
             ...[...this.mcpPrompts.values()].map((prompt) => ({
                 name: prompt.userFacingName,

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

@@ -0,0 +1,4 @@
+export declare function enhancedClaudeInitEnabled(environment?: NodeJS.ProcessEnv): boolean;
+export declare function claudeInitDescription(environment?: NodeJS.ProcessEnv): string;
+export declare function claudeInitPrompt(environment?: NodeJS.ProcessEnv): string;
+//# sourceMappingURL=claude-init-command.d.ts.map