praxis-agent 0.11.0 → 0.13.0

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/sandbox-dashboard.d.ts

@@ -0,0 +1,10 @@
+import type { TuiSandboxSnapshot, TuiSandboxTab } from './sandbox-settings.js';
+export declare function tuiSandboxTabs(snapshot: TuiSandboxSnapshot): readonly TuiSandboxTab[];
+export declare function SandboxDashboard({ snapshot, tab, selectedIndex, width, screenReader, }: {
+    snapshot: TuiSandboxSnapshot;
+    tab: TuiSandboxTab;
+    selectedIndex: number;
+    width: number;
+    screenReader: boolean;
+}): import("react").JSX.Element;
+//# sourceMappingURL=sandbox-dashboard.d.ts.map

package/dist/cli/tui/sandbox-dashboard.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+const TABS = {
+    mode: 'Mode',
+    dependencies: 'Dependencies',
+    overrides: 'Overrides',
+    config: 'Config',
+};
+export function tuiSandboxTabs(snapshot) {
+    if (snapshot.dependencies.errors.length > 0)
+        return ['dependencies'];
+    return [
+        'mode',
+        ...(snapshot.dependencies.warnings.length > 0
+            ? ['dependencies']
+            : []),
+        'overrides',
+        'config',
+    ];
+}
+function prefix(selected, screenReader) {
+    if (screenReader)
+        return selected ? 'Selected: ' : '';
+    return selected ? '❯ ' : '  ';
+}
+export function SandboxDashboard({ snapshot, tab, selectedIndex, width, screenReader, }) {
+    const tabs = tuiSandboxTabs(snapshot);
+    const mode = !snapshot.settings.enabled
+        ? 'disabled'
+        : snapshot.settings.autoAllowBashIfSandboxed
+            ? 'auto-allow'
+            : 'regular';
+    const modeRows = [
+        {
+            value: 'auto-allow',
+            label: 'Sandbox BashTool, with auto-allow',
+        },
+        {
+            value: 'regular',
+            label: 'Sandbox BashTool, with regular permissions',
+        },
+        { value: 'disabled', label: 'No Sandbox' },
+    ];
+    const overrideRows = [
+        {
+            value: true,
+            label: 'Allow unsandboxed fallback',
+        },
+        {
+            value: false,
+            label: 'Strict sandbox mode',
+        },
+    ];
+    const filesystem = snapshot.settings.runtimeConfig.filesystem;
+    const network = snapshot.settings.runtimeConfig.network;
+    return (_jsxs(Box, { flexDirection: "column", width: Math.min(100, width), children: [!screenReader ? (_jsx(Text, { dimColor: true, children: '─'.repeat(Math.min(100, width)) })) : null, _jsx(Text, { bold: true, children: " Sandbox:" }), _jsxs(Text, { children: ['  ', tabs.map((candidate) => (_jsxs(Text, { inverse: !screenReader && candidate === tab, children: [screenReader && candidate === tab ? 'Current tab: ' : ' ', TABS[candidate], ' '] }, candidate)))] }), _jsx(Text, { children: " " }), tab === 'mode' ? (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: " Configure Mode:" }), _jsx(Text, { children: " " }), modeRows.map((row, index) => (_jsxs(Text, { inverse: !screenReader && selectedIndex === index, children: [prefix(selectedIndex === index, screenReader), index + 1, ". ", row.label, row.value === mode ? ' (current)' : ''] }, row.value))), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: "Auto-allow mode runs Bash in the sandbox automatically. Explicit ask and deny rules are always respected." })] })) : tab === 'dependencies' ? (_jsxs(Box, { flexDirection: "column", children: [snapshot.platform === 'macos' ? (_jsxs(Text, { children: ["seatbelt: ", _jsx(Text, { color: "green", children: "built-in (macOS)" })] })) : (_jsxs(_Fragment, { children: [_jsxs(Text, { children: ["bubblewrap (bwrap):", ' ', _jsx(Text, { color: snapshot.dependencies.errors.some((error) => error.includes('bwrap'))
+                                            ? 'red'
+                                            : 'green', children: snapshot.dependencies.errors.some((error) => error.includes('bwrap'))
+                                            ? 'not installed'
+                                            : 'installed' })] }), _jsxs(Text, { children: ["socat:", ' ', _jsx(Text, { color: snapshot.dependencies.errors.some((error) => error.includes('socat'))
+                                            ? 'red'
+                                            : 'green', children: snapshot.dependencies.errors.some((error) => error.includes('socat'))
+                                            ? 'not installed'
+                                            : 'installed' })] }), _jsxs(Text, { children: ["seccomp filter:", ' ', _jsx(Text, { color: snapshot.dependencies.warnings.length > 0
+                                            ? 'yellow'
+                                            : 'green', children: snapshot.dependencies.warnings.length > 0
+                                            ? 'not installed'
+                                            : 'installed' })] })] })), _jsxs(Text, { children: ["ripgrep (rg):", ' ', _jsx(Text, { color: snapshot.dependencies.errors.some((error) => error.includes('ripgrep'))
+                                    ? 'red'
+                                    : 'green', children: snapshot.dependencies.errors.some((error) => error.includes('ripgrep'))
+                                    ? 'not found'
+                                    : 'found' })] }), snapshot.dependencies.errors.map((error) => (_jsx(Text, { color: "red", children: error }, error))), snapshot.dependencies.warnings.map((warning) => (_jsx(Text, { color: "yellow", children: warning }, warning))), snapshot.unavailableReason ? (_jsx(Text, { color: "red", children: snapshot.unavailableReason })) : null] })) : tab === 'overrides' ? (_jsxs(_Fragment, { children: [!snapshot.settings.enabled ? (_jsx(Text, { dimColor: true, children: "Sandbox is not enabled" })) : (overrideRows.map((row, index) => (_jsxs(Text, { inverse: !screenReader && selectedIndex === index, children: [prefix(selectedIndex === index, screenReader), index + 1, ". ", row.label, row.value === snapshot.settings.allowUnsandboxedCommands
+                                ? ' (current)'
+                                : ''] }, String(row.value))))), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: "Closed mode ignores dangerouslyDisableSandbox and requires commands to remain sandboxed." })] })) : !snapshot.settings.enabled ? (_jsx(Text, { dimColor: true, children: "Sandbox is not enabled" })) : (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Excluded Commands:" }), _jsx(Text, { dimColor: true, children: snapshot.settings.excludedCommands.join(', ') || 'None' }), _jsx(Text, { bold: true, children: "Filesystem Read Restrictions:" }), _jsxs(Text, { dimColor: true, children: ["Denied: ", filesystem?.denyRead?.join(', ') || 'None'] }), _jsxs(Text, { dimColor: true, children: ["Allowed within denied: ", filesystem?.allowRead?.join(', ') || 'None'] }), _jsx(Text, { bold: true, children: "Filesystem Write Restrictions:" }), _jsxs(Text, { dimColor: true, children: ["Allowed: ", filesystem?.allowWrite?.join(', ') || 'None'] }), _jsxs(Text, { dimColor: true, children: ["Denied within allowed: ", filesystem?.denyWrite?.join(', ') || 'None'] }), _jsx(Text, { bold: true, children: "Network Restrictions:" }), _jsxs(Text, { dimColor: true, children: ["Allowed: ", network?.allowedDomains?.join(', ') || 'None'] }), _jsxs(Text, { dimColor: true, children: ["Denied: ", network?.deniedDomains?.join(', ') || 'None'] }), _jsx(Text, { bold: true, children: "Allowed Unix Sockets:" }), _jsx(Text, { dimColor: true, children: network?.allowUnixSockets?.join(', ') || 'None' }), (snapshot.globPatternWarnings?.length ?? 0) > 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, color: "yellow", children: "\u26A0 Warning: Glob patterns not fully supported on Linux" }), _jsx(Text, { dimColor: true, children: snapshot.globPatternWarnings?.slice(0, 3).join(', ') })] })) : null] })), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: tab === 'mode' || (tab === 'overrides' && snapshot.settings.enabled)
+                    ? '↑/↓ navigate · Enter to select · ←/→ switch tabs · Esc to cancel'
+                    : '←/→ switch tabs · Esc to cancel' })] }));
+}
+//# sourceMappingURL=sandbox-dashboard.js.map

package/dist/cli/tui/sandbox-settings.d.ts

@@ -0,0 +1,32 @@
+import type { SandboxDependencyCheck } from '@anthropic-ai/sandbox-runtime';
+import { loadClaudeSettings } from '../../compatibility/claude/shared-resources.js';
+import { type ClaudeSandboxSettings } from '../../sandbox/claude-sandbox-settings.js';
+export type TuiSandboxMode = 'auto-allow' | 'regular' | 'disabled';
+export type TuiSandboxTab = 'mode' | 'dependencies' | 'overrides' | 'config';
+export interface TuiSandboxSnapshot {
+    settings: ClaudeSandboxSettings;
+    dependencies: SandboxDependencyCheck;
+    supported: boolean;
+    platform: 'macos' | 'linux' | 'windows' | 'wsl';
+    globPatternWarnings?: readonly string[];
+    unavailableReason?: string;
+}
+export interface TuiSandboxStore {
+    load(): Promise<TuiSandboxSnapshot>;
+    setMode(mode: TuiSandboxMode): Promise<TuiSandboxSnapshot>;
+    setAllowUnsandboxedCommands(allow: boolean): Promise<TuiSandboxSnapshot>;
+    exclude(pattern: string): Promise<{
+        pattern: string;
+        settingsPath: string;
+        snapshot: TuiSandboxSnapshot;
+    }>;
+}
+export declare function linuxGlobPatternWarnings(resources: Awaited<ReturnType<typeof loadClaudeSettings>>, platform: 'macos' | 'linux' | 'windows' | 'wsl'): string[];
+export declare function createTuiSandboxStore({ configRoot, cwd, homeDirectory, additionalDirectories, environment, }: {
+    configRoot: string;
+    cwd: string;
+    homeDirectory: string;
+    additionalDirectories?: readonly string[];
+    environment?: NodeJS.ProcessEnv;
+}): TuiSandboxStore;
+//# sourceMappingURL=sandbox-settings.d.ts.map

package/dist/cli/tui/sandbox-settings.js

@@ -0,0 +1,146 @@
+import { readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { loadClaudeSettings } from '../../compatibility/claude/shared-resources.js';
+import { writeFileAtomically } from '../../platform/atomic-write.js';
+import { claudeSandboxRuntime } from '../../sandbox/claude-sandbox-runtime.js';
+import { claudeSandboxTempDirectory, loadClaudeSandboxSettings, } from '../../sandbox/claude-sandbox-settings.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+async function readLocalSettings(path) {
+    try {
+        const value = JSON.parse(await readFile(path, 'utf8'));
+        if (!isRecord(value))
+            throw new Error(`Settings must be an object: ${path}`);
+        return value;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return {};
+        throw error;
+    }
+}
+async function updateLocalSandbox(path, update) {
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        let source;
+        try {
+            source = await readFile(path, 'utf8');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const settings = await readLocalSettings(path);
+        const current = settings.sandbox;
+        if (current !== undefined && !isRecord(current)) {
+            throw new Error(`sandbox must be an object: ${path}`);
+        }
+        const committed = await writeFileAtomically(path, `${JSON.stringify({ ...settings, sandbox: update(current ?? {}) }, null, 2)}\n`, {
+            beforeCommit: async () => {
+                try {
+                    return (await readFile(path, 'utf8')) === source;
+                }
+                catch (error) {
+                    if (error.code === 'ENOENT')
+                        return source === undefined;
+                    throw error;
+                }
+            },
+        });
+        if (committed)
+            return;
+    }
+    throw new Error(`Settings changed concurrently: ${path}`);
+}
+export function linuxGlobPatternWarnings(resources, platform) {
+    if (platform !== 'linux' && platform !== 'wsl')
+        return [];
+    const warnings = [];
+    for (const resource of resources) {
+        if (!isRecord(resource.value) || !isRecord(resource.value.permissions))
+            continue;
+        for (const behavior of ['allow', 'deny']) {
+            const rules = resource.value.permissions[behavior];
+            if (!Array.isArray(rules))
+                continue;
+            for (const rule of rules) {
+                if (typeof rule !== 'string')
+                    continue;
+                const match = /^(?:Edit|Read)\((.*)\)$/u.exec(rule);
+                const pattern = match?.[1]?.replace(/\/\*\*$/u, '');
+                if (pattern && /[*?[\]]/u.test(pattern))
+                    warnings.push(rule);
+            }
+        }
+    }
+    return [...new Set(warnings)];
+}
+export function createTuiSandboxStore({ configRoot, cwd, homeDirectory, additionalDirectories = [], environment = process.env, }) {
+    const localSettingsPath = join(cwd, '.claude', 'settings.local.json');
+    const load = async () => {
+        const resources = await loadClaudeSettings({ configRoot, cwd });
+        const settings = loadClaudeSandboxSettings({
+            resources,
+            cwd,
+            configRoot,
+            homeDirectory,
+            additionalDirectories,
+            tempDirectory: claudeSandboxTempDirectory(environment),
+        });
+        await claudeSandboxRuntime.initialize(settings);
+        const unavailableReason = claudeSandboxRuntime.unavailableReason(settings);
+        const platform = claudeSandboxRuntime.platformName();
+        return {
+            settings,
+            dependencies: claudeSandboxRuntime.dependencyCheck(settings),
+            supported: claudeSandboxRuntime.isSupportedPlatform(),
+            platform,
+            globPatternWarnings: linuxGlobPatternWarnings(resources, platform),
+            ...(unavailableReason ? { unavailableReason } : {}),
+        };
+    };
+    return {
+        load,
+        async setMode(mode) {
+            await updateLocalSandbox(localSettingsPath, (sandbox) => ({
+                ...sandbox,
+                enabled: mode !== 'disabled',
+                autoAllowBashIfSandboxed: mode === 'auto-allow',
+            }));
+            return load();
+        },
+        async setAllowUnsandboxedCommands(allow) {
+            await updateLocalSandbox(localSettingsPath, (sandbox) => ({
+                ...sandbox,
+                allowUnsandboxedCommands: allow,
+            }));
+            return load();
+        },
+        async exclude(pattern) {
+            const cleanPattern = pattern.trim().replace(/^["']|["']$/gu, '');
+            if (!cleanPattern) {
+                throw new Error('Please provide a command pattern to exclude');
+            }
+            await updateLocalSandbox(localSettingsPath, (sandbox) => {
+                const excluded = sandbox.excludedCommands;
+                if (excluded !== undefined &&
+                    (!Array.isArray(excluded) ||
+                        excluded.some((value) => typeof value !== 'string'))) {
+                    throw new Error(`sandbox.excludedCommands must be an array of strings: ${localSettingsPath}`);
+                }
+                return {
+                    ...sandbox,
+                    excludedCommands: [
+                        ...new Set([...(excluded ?? []), cleanPattern]),
+                    ],
+                };
+            });
+            return {
+                pattern: cleanPattern,
+                settingsPath: relative(cwd, localSettingsPath),
+                snapshot: await load(),
+            };
+        },
+    };
+}
+//# sourceMappingURL=sandbox-settings.js.map

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

@@ -64,6 +64,11 @@ export const BUILTIN_TUI_SLASH_COMMANDS = [
         description: 'Manage allow and deny tool permission rules',
         source: 'builtin',
     },
+    {
+        name: 'sandbox',
+        description: 'Configure sandbox mode and command isolation',
+        source: 'builtin',
+    },
     {
         name: 'resume',
         description: 'Resume a previous conversation',
@@ -119,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