praxis-agent 0.7.0 → 0.9.0

package/dist/application/session-service.js

@@ -14,6 +14,7 @@ import { selectClaudeSchemaAdapter, } from '../compatibility/claude/schema.js';
 import { findUnresolvedClaudeToolCalls } from '../compatibility/claude/tool-links.js';
 import { createClaudeAgentSettingEntry, createClaudeHookAttachmentEntries, createClaudeLastPromptEntry, createClaudeRuleAttachmentEntry, translateProviderEvents, } from '../compatibility/claude/translation.js';
 import { AgentRunCancelledError, AgentRuntime, } from '../core/runtime.js';
+import { BackgroundTaskRuntime, } from './background-task-runtime.js';
 import { usageCostUsd } from '../core/usage.js';
 import { ContextBudget, estimateModelRequestTokens, } from '../core/context-budget.js';
 import { injectFirstUserMessageContext, } from '../core/context.js';
@@ -26,7 +27,7 @@ import { ScheduledPromptManager } from './scheduled-prompt-manager.js';
 import { ClaudeScheduledToolRegistry } from '../tools/claude-scheduled-tools.js';
 import { ClaudeTaskToolRegistry } from '../tools/claude-task-tools.js';
 import { ClaudeWorkflowToolRegistry } from '../tools/claude-workflow-tools.js';
-import { WorkflowManager } from './workflow-manager.js';
+import { WorkflowManager, } from './workflow-manager.js';
 import { SessionWorktreeManager } from './session-worktree.js';
 import { ClaudeWorktreeToolRegistry } from '../tools/claude-worktree-tools.js';
 import { generateToolUseSummary } from './tool-use-summary.js';
@@ -88,12 +89,14 @@ export class ClaudeSessionService {
     inMemoryStores = new Map();
     scheduledPrompts;
     workflowManager;
+    backgroundTasks;
     worktreeManager;
     sessionCwds = new Map();
     hostedSubagents = new Set();
     hostedSubagentsByRegistry = new WeakMap();
     backgroundNotificationWrites = new Map();
     downloadedFileResourceSessions = new Set();
+    mcpClosePromise;
     runtimeCwd;
     constructor(options) {
         this.options = options;
@@ -112,11 +115,15 @@ export class ClaudeSessionService {
         this.workflowManager = options.enableWorkflows
             ? new WorkflowManager(options.configRoot, options.cwd, () => this.activeCwd())
             : null;
+        this.backgroundTasks = new BackgroundTaskRuntime(this.workflowManager);
         this.worktreeManager =
             options.enableWorktrees && options.workspace
                 ? new SessionWorktreeManager({
                     workspace: options.workspace,
                     sessionId: '',
+                    ...(options.worktreeBaseRef
+                        ? { baseRef: options.worktreeBaseRef }
+                        : {}),
                 })
                 : null;
     }
@@ -126,13 +133,42 @@ export class ClaudeSessionService {
     workflows() {
         return this.workflowManager?.list() ?? [];
     }
+    mcpInspect() {
+        return this.requireMcp().inspect();
+    }
+    mcpReconnect(name) {
+        return this.requireMcp().reconnect(name);
+    }
+    mcpAuthenticate(name) {
+        return this.requireMcp().authenticate(name);
+    }
+    mcpReload() {
+        return this.requireMcp().reload();
+    }
+    mcpTools(name) {
+        return this.requireMcp().tools(name);
+    }
+    requireMcp() {
+        if (!this.options.mcp)
+            throw new Error('MCP runtime is not configured');
+        return this.options.mcp;
+    }
+    taskSnapshots(sessionId) {
+        return this.backgroundTasks.snapshot(sessionId);
+    }
+    stopTask(sessionId, taskId) {
+        return this.backgroundTasks.stop(sessionId, taskId);
+    }
     async close() {
         this.scheduledPrompts?.close();
         await Promise.all([...this.hostedSubagents].map((executor) => executor.close()));
         await Promise.resolve();
         await Promise.all([...this.backgroundNotificationWrites.values()]);
         this.hostedSubagents.clear();
+        this.backgroundTasks.clear();
         await this.workflowManager?.close();
+        this.mcpClosePromise ??= this.options.mcp?.close?.() ?? Promise.resolve();
+        await this.mcpClosePromise;
     }
     createHostedToolRegistry(sessionId) {
         const baseTools = this.options.tools;
@@ -155,6 +191,8 @@ export class ClaudeSessionService {
                     : {}),
             })
             : null;
+        if (taskTools)
+            this.backgroundTasks.registerBash(sessionId, taskTools);
         const scheduledTools = this.scheduledPrompts &&
             (this.options.scheduledToolNames?.length ?? 0) > 0
             ? new ClaudeScheduledToolRegistry({
@@ -221,6 +259,9 @@ export class ClaudeSessionService {
             : null;
         if (subagentExecutor)
             this.hostedSubagents.add(subagentExecutor);
+        if (subagentExecutor) {
+            this.backgroundTasks.registerAgents(sessionId, subagentExecutor);
+        }
         const agentTools = subagentExecutor
             ? subagentExecutor.registry(sessionId, 0, (callId) => callId)
             : wrappedBase;
@@ -810,6 +851,13 @@ export class ClaudeSessionService {
             throw new Error(`Claude cd usage conflict: ${result.reason}`);
         }
     }
+    async approveRecentlyDenied(sessionId, display) {
+        await this.appendPermissionGrant(sessionId, display, false);
+    }
+    async retryRecentlyDenied(sessionId, display, signal) {
+        await this.appendPermissionGrant(sessionId, display, true);
+        return this.executeTurn(sessionId, '/permissions', true, signal, undefined, [], [], undefined, undefined, true);
+    }
     async recordBtwUsage(sessionId, permissionMode = 'default') {
         const activeSessionId = await this.ensureLocalSession(sessionId, permissionMode);
         await this.appendInputHistory('/btw', activeSessionId);
@@ -1188,7 +1236,7 @@ export class ClaudeSessionService {
             throw new Error(`Claude permission mode update conflict: ${result.reason}`);
         }
     }
-    async executeTurn(sessionId, prompt, requireExisting, signal, name, images = [], documents = [], resumeSessionAt, shellCommand) {
+    async executeTurn(sessionId, prompt, requireExisting, signal, name, images = [], documents = [], resumeSessionAt, shellCommand, skipUserPrompt = false) {
         this.assertWritable();
         if (prompt.length === 0 && images.length === 0 && documents.length === 0)
             throw new Error('Prompt must not be empty');
@@ -1205,6 +1253,10 @@ export class ClaudeSessionService {
         }
         const pinnedCwd = this.sessionCwds.get(sessionId) ?? this.activeCwd();
         this.sessionCwds.set(sessionId, pinnedCwd);
+        if (this.options.workspace?.cwd() !== pinnedCwd) {
+            this.options.workspace?.setCwd(pinnedCwd);
+        }
+        this.runtimeCwd = pinnedCwd;
         const sessionPaths = this.paths(sessionId);
         const toolResultDirectory = join(sessionPaths.projectRoot, sessionId, 'tool-results');
         const store = this.turnStore(sessionId);
@@ -1470,6 +1522,10 @@ export class ClaudeSessionService {
                         if (typeof path !== 'string') {
                             return interactiveMessageTools.execute(call, context);
                         }
+                        if ((call.name === 'Write' || call.name === 'Edit') &&
+                            (await this.options.interactiveTools?.isPlanFile(sessionId, path))) {
+                            return interactiveMessageTools.execute(call, context);
+                        }
                         const snapshotMessageId = currentPromptId ??
                             this.promptIdForToolCall(snapshot.entries, call.id);
                         const assistantMessageId = lastAssistantUuid ??
@@ -1743,13 +1799,15 @@ export class ClaudeSessionService {
                         ]
                         : []),
                 ];
-                const expansion = shellCommand === undefined
-                    ? this.options.extensions
-                        ? await this.options.extensions.expandPromptAsync(prompt, signal, toolResultDirectory)
-                        : { userMessages: [prompt] }
-                    : {
-                        userMessages: [`<bash-input>${shellCommand}</bash-input>`],
-                    };
+                const expansion = skipUserPrompt
+                    ? { userMessages: [] }
+                    : shellCommand === undefined
+                        ? this.options.extensions
+                            ? await this.options.extensions.expandPromptAsync(prompt, signal, toolResultDirectory)
+                            : { userMessages: [prompt] }
+                        : {
+                            userMessages: [`<bash-input>${shellCommand}</bash-input>`],
+                        };
                 const expandedMessages = expansion.messages ?? expansion.userMessages.map((text) => ({ text }));
                 const attachmentIndex = expansion.messages
                     ? expandedMessages.length - 1
@@ -1786,7 +1844,7 @@ export class ClaudeSessionService {
                         ? { documents }
                         : {}),
                 }));
-                const agentMentionMessages = shellCommand === undefined
+                const agentMentionMessages = shellCommand === undefined && !skipUserPrompt
                     ? (this.options.extensions?.agentMentionMessages(prompt) ?? [])
                     : [];
                 const injectAgentMentionContext = (messages) => {
@@ -1819,7 +1877,7 @@ export class ClaudeSessionService {
                 const injectTurnContext = (messages) => injectAgentMentionContext(injectDynamicContext(messages));
                 let compactionAnchorUuid = this.lastMessageUuid(snapshot.entries);
                 const compactIfNeeded = async (pendingMessages = [], preservedUserMessages = []) => {
-                    if (!budget)
+                    if (!budget || this.options.autoCompact === false)
                         return;
                     const historyMessages = projectClaudeModelMessages(snapshot.entries);
                     const predicted = budget.evaluate([
@@ -1991,7 +2049,7 @@ export class ClaudeSessionService {
                         tail: historyTail,
                     };
                 }
-                if (this.options.hooks) {
+                if (this.options.hooks && !skipUserPrompt) {
                     const outcome = await this.options.hooks.run({
                         ...hookSession,
                         hook_event_name: 'UserPromptSubmit',
@@ -2168,11 +2226,13 @@ export class ClaudeSessionService {
                 if (!finalLeafUuid) {
                     throw new Error('Could not locate final assistant response');
                 }
-                await this.append(lease, snapshot.tail, createClaudeLastPromptEntry({
-                    sessionId,
-                    lastPrompt: prompt,
-                    leafUuid: finalLeafUuid,
-                }));
+                if (!skipUserPrompt) {
+                    await this.append(lease, snapshot.tail, createClaudeLastPromptEntry({
+                        sessionId,
+                        lastPrompt: prompt,
+                        leafUuid: finalLeafUuid,
+                    }));
+                }
                 const totalUsage = mergeUsage(mergeUsage(mergeUsage(recoveryUsage, compactionUsage), shellUsage), result.usage);
                 return {
                     sessionId,
@@ -2494,6 +2554,117 @@ export class ClaudeSessionService {
             sessionId,
         })}\n`, 'utf8');
     }
+    async appendPermissionGrant(sessionId, display, retry) {
+        this.assertWritable();
+        const normalized = display.trim();
+        if (!normalized)
+            throw new Error('Permission action must not be empty');
+        while (true) {
+            const result = await this.turnStore(sessionId).withLease(async (lease) => {
+                const snapshot = await lease.load();
+                if (snapshot.entries.length === 0) {
+                    throw new Error(`Claude session not found: ${sessionId}`);
+                }
+                const timestamp = new Date().toISOString();
+                const promptId = randomUUID();
+                const commandUuid = randomUUID();
+                const common = {
+                    isSidechain: false,
+                    promptId,
+                    timestamp,
+                    userType: 'external',
+                    entrypoint: 'cli',
+                    cwd: this.activeCwd(),
+                    sessionId,
+                    version: this.options.claudeVersion,
+                    gitBranch: null,
+                };
+                let parentUuid = this.logicalTailUuid(snapshot.tail);
+                const entries = [];
+                if (this.options.fileCheckpointing &&
+                    this.options.sessionPersistence !== false) {
+                    const fileHistory = new ClaudeFileHistory(this.options.configRoot, sessionId, [this.activeCwd(), ...(this.options.fileRewindRoots ?? [])]);
+                    entries.push(await fileHistory.snapshot(snapshot.entries, commandUuid));
+                }
+                if (retry) {
+                    const retryUuid = randomUUID();
+                    entries.push({
+                        parentUuid,
+                        isSidechain: false,
+                        type: 'system',
+                        subtype: 'permission_retry',
+                        content: `Allowed ${normalized}`,
+                        commands: [normalized],
+                        level: 'info',
+                        isMeta: false,
+                        timestamp,
+                        uuid: retryUuid,
+                        userType: 'external',
+                        entrypoint: 'cli',
+                        cwd: this.activeCwd(),
+                        sessionId,
+                        version: this.options.claudeVersion,
+                        gitBranch: null,
+                    });
+                    parentUuid = retryUuid;
+                }
+                else {
+                    const caveatUuid = randomUUID();
+                    entries.push({
+                        ...common,
+                        parentUuid,
+                        type: 'user',
+                        message: {
+                            role: 'user',
+                            content: '<local-command-caveat>Caveat: The messages below were generated by the user while running local commands. DO NOT respond to these messages or otherwise consider them in your response unless the user explicitly asks you to.</local-command-caveat>',
+                        },
+                        isMeta: true,
+                        uuid: caveatUuid,
+                    });
+                    parentUuid = caveatUuid;
+                }
+                entries.push({
+                    ...common,
+                    parentUuid,
+                    type: 'user',
+                    message: {
+                        role: 'user',
+                        content: '<command-name>/permissions</command-name>\n            <command-message>permissions</command-message>\n            <command-args></command-args>',
+                    },
+                    uuid: commandUuid,
+                });
+                const outputUuid = randomUUID();
+                entries.push({
+                    ...common,
+                    parentUuid: commandUuid,
+                    type: 'user',
+                    message: {
+                        role: 'user',
+                        content: `<local-command-stdout>${retry ? '(no content)' : `Approved ${normalized}`}</local-command-stdout>`,
+                    },
+                    uuid: outputUuid,
+                });
+                entries.push({
+                    ...common,
+                    parentUuid: outputUuid,
+                    type: 'user',
+                    message: {
+                        role: 'user',
+                        content: `Permission granted for: ${normalized}. You may now retry this command if you would like.`,
+                    },
+                    isMeta: true,
+                    uuid: randomUUID(),
+                });
+                const appended = await lease.appendMany(snapshot.tail, entries);
+                if (appended.status === 'conflict') {
+                    throw new Error(`Claude permission grant append conflict: ${appended.reason}`);
+                }
+            });
+            if (result.status === 'completed')
+                return;
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+    }
     async appendBackgroundNotification(sessionId, content) {
         while (true) {
             const result = await this.turnStore(sessionId).withLease(async (lease) => {

package/dist/application/session-worktree.d.ts

@@ -28,6 +28,7 @@ export declare class SessionWorktreeManager {
     constructor(options: {
         workspace: WorkspaceContext;
         sessionId: string;
+        baseRef?: 'fresh' | 'head';
     });
     bindSession(sessionId: string): void;
     current(): WorktreeSessionState | null;

package/dist/application/session-worktree.js

@@ -143,14 +143,25 @@ export class SessionWorktreeManager {
             }
             const worktreePath = join(root, '.claude', 'worktrees', name);
             const branch = `worktree-${nameFromPath(name)}`;
+            const baseCommit = this.options.baseRef === 'head'
+                ? originalHeadCommit
+                : ((await gitOptional(root, ['merge-base', 'HEAD', '@{upstream}'])) ??
+                    originalHeadCommit);
             await mkdir(join(root, '.claude', 'worktrees'), { recursive: true });
             try {
-                await git(root, ['worktree', 'add', '-b', branch, worktreePath, 'HEAD']);
+                await git(root, [
+                    'worktree',
+                    'add',
+                    '-b',
+                    branch,
+                    worktreePath,
+                    baseCommit,
+                ]);
                 const gitDirectory = await git(worktreePath, ['rev-parse', '--git-dir']);
                 const absoluteGitDirectory = isAbsolute(gitDirectory)
                     ? gitDirectory
                     : resolve(worktreePath, gitDirectory);
-                await writeFile(join(absoluteGitDirectory, 'CLAUDE_BASE'), `${originalHeadCommit}\n`);
+                await writeFile(join(absoluteGitDirectory, 'CLAUDE_BASE'), `${baseCommit}\n`);
             }
             catch (error) {
                 await execFileAsync('git', ['-C', root, 'worktree', 'remove', '--force', worktreePath], {

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

@@ -3,6 +3,7 @@ import { type ContextAssembler } from '../core/context.js';
 import { type ModelProvider, type ModelToolCall, type ModelToolDefinition, type ModelUsage, type PermissionResolver, type PermissionApproval, type RuntimeEventSink, type ToolExecutionContext, type ToolExecutionResult, type ToolRegistry } from '../core/runtime.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 {
     sessionId: string;
     promptId: string;
@@ -74,6 +75,8 @@ export declare class ClaudeSubagentExecutor {
     isEnabled(name: string): boolean;
     constructor(options: ClaudeSubagentExecutorOptions);
     close(): Promise<void>;
+    backgroundSnapshots(): readonly BackgroundAgentSnapshot[];
+    stopBackgroundTask(taskId: string): string;
     private cwd;
     registry(sessionId: string, depth: number, promptIdForCall: (callId: string) => string | null): ToolRegistry;
     definitions(): ModelToolDefinition;

package/dist/application/subagent-service.js

@@ -176,6 +176,12 @@ export class ClaudeSubagentExecutor {
         await this.background.close();
         this.ephemeralSidechains.clear();
     }
+    backgroundSnapshots() {
+        return this.background.snapshots();
+    }
+    stopBackgroundTask(taskId) {
+        return this.background.stop(taskId);
+    }
     cwd() {
         return this.options.cwdProvider?.() ?? this.options.cwd;
     }

package/dist/application/workflow-manager.d.ts

@@ -1,5 +1,6 @@
+import { ClaudeWorkflowStore } from '../persistence/claude-workflow-store.js';
 import type { WorkflowAgentRunOptions, WorkflowAgentRunResult } from './subagent-service.js';
-import { parseWorkflowScript, type ParsedWorkflowScript } from './workflow-meta.js';
+import { parseWorkflowScript, type ParsedWorkflowScript, type WorkflowMeta } from './workflow-meta.js';
 export interface WorkflowSource {
     script: string;
     parsed: ParsedWorkflowScript;
@@ -24,6 +25,71 @@ export interface WorkflowLaunchResult {
     scriptFile: string;
     transcriptDirectory: string;
 }
+export interface WorkflowProgress {
+    index: number;
+    agentId: string;
+    label: string;
+    phase?: string;
+    status: 'running' | 'completed' | 'error';
+    cached?: boolean;
+    result?: unknown;
+    error?: string;
+    totalTokens: number;
+    toolCalls: number;
+    durationMs: number;
+    resolvedModel?: string;
+    requestedModel?: string;
+    requestedAgentType?: string;
+    queuedAt: number;
+    startedAt?: number;
+    promptPreview: string;
+    isolationPath?: string;
+    isolationRetained?: boolean;
+    isolationWarning?: string;
+}
+interface WorkflowTask {
+    taskId: string;
+    runId: string;
+    sessionId: string;
+    meta: WorkflowMeta;
+    script: string;
+    scriptFile: string;
+    transcriptDirectory: string;
+    store: ClaudeWorkflowStore;
+    args: unknown;
+    defaultModel: string;
+    startTime: number;
+    durationMs: number | null;
+    status: 'running' | 'completed' | 'failed' | 'killed';
+    result: unknown;
+    error?: string;
+    logs: string[];
+    phases: {
+        title: string;
+        detail?: string;
+        model?: string;
+    }[];
+    progress: WorkflowProgress[];
+    agentCount: number;
+    totalTokens: number;
+    totalInputTokens: number;
+    totalToolCalls: number;
+    controller: AbortController;
+    promise: Promise<void>;
+    notificationPending: boolean;
+}
+export interface WorkflowTaskSnapshot {
+    task_id: string;
+    task_type: 'local_workflow';
+    status: WorkflowTask['status'];
+    summary: string;
+    run_id: string;
+    progress: readonly WorkflowProgress[];
+    result: unknown;
+    startTime: number;
+    durationMs: number;
+    error?: string;
+}
 export declare class WorkflowManager {
     private readonly configRoot;
     private readonly cwd;
@@ -32,11 +98,13 @@ export declare class WorkflowManager {
     private readonly activeRuns;
     launch(options: WorkflowLaunchOptions): Promise<WorkflowLaunchResult>;
     has(taskId: string): boolean;
+    hasForSession(sessionId: string, taskId: string): boolean;
     output(taskId: string, options: {
         block: boolean;
         timeout: number;
     }): Promise<string>;
     stop(taskId: string): string;
+    stopAndWait(taskId: string): Promise<void>;
     notifications(waitForRunning: boolean): Promise<{
         messages: string[];
         usage: {
@@ -44,7 +112,7 @@ export declare class WorkflowManager {
             outputTokens: number;
         };
     }>;
-    list(): readonly Record<string, unknown>[];
+    list(sessionId?: string): readonly WorkflowTaskSnapshot[];
     abortAll(): void;
     close(): Promise<void>;
     constructor(configRoot: string, cwd: string, cwdProvider?: (() => string) | undefined);

package/dist/application/workflow-manager.js

@@ -130,6 +130,7 @@ export class WorkflowManager {
             args: structuredClone(options.args),
             defaultModel: options.defaultModel,
             startTime: Date.now(),
+            durationMs: null,
             status: 'running',
             result: null,
             logs: [],
@@ -167,6 +168,9 @@ export class WorkflowManager {
     has(taskId) {
         return this.tasks.has(taskId);
     }
+    hasForSession(sessionId, taskId) {
+        return this.tasks.get(taskId)?.sessionId === sessionId;
+    }
     async output(taskId, options) {
         const task = this.task(taskId);
         if (options.block && task.status === 'running') {
@@ -200,6 +204,14 @@ export class WorkflowManager {
             command: task.meta.description,
         });
     }
+    async stopAndWait(taskId) {
+        const task = this.task(taskId);
+        if (task.status !== 'running') {
+            throw new Error(`Task ${taskId} is not running (status: ${task.status})`);
+        }
+        task.controller.abort('TaskStop');
+        await task.promise;
+    }
     async notifications(waitForRunning) {
         if (waitForRunning) {
             await Promise.all([...this.tasks.values()]
@@ -222,8 +234,10 @@ export class WorkflowManager {
             usage: { inputTokens, outputTokens },
         };
     }
-    list() {
-        return [...this.tasks.values()].map((task) => this.summary(task));
+    list(sessionId) {
+        return [...this.tasks.values()]
+            .filter((task) => sessionId === undefined || task.sessionId === sessionId)
+            .map((task) => this.summary(task));
     }
     abortAll() {
         for (const task of this.tasks.values()) {
@@ -444,12 +458,13 @@ export class WorkflowManager {
             task.error = `${error instanceof Error ? (error.stack ?? error.message) : String(error)}`;
         }
         finally {
+            task.durationMs = Date.now() - task.startTime;
             task.notificationPending = true;
             await task.store.writeRun(this.runRecord(task));
         }
     }
     runRecord(task) {
-        const durationMs = Date.now() - task.startTime;
+        const durationMs = task.durationMs ?? Date.now() - task.startTime;
         return {
             runId: task.runId,
             timestamp: new Date().toISOString(),
@@ -482,6 +497,8 @@ export class WorkflowManager {
             run_id: task.runId,
             progress: task.progress,
             result: task.result,
+            startTime: task.startTime,
+            durationMs: task.durationMs ?? Date.now() - task.startTime,
             ...(task.error ? { error: task.error } : {}),
         };
     }
@@ -558,7 +575,7 @@ export class WorkflowManager {
             `agents_empty_result: ${empty}`,
             `subagent_tokens: ${task.totalTokens}`,
             `tool_uses: ${task.totalToolCalls}`,
-            `duration_ms: ${Date.now() - task.startTime}`,
+            `duration_ms: ${task.durationMs ?? Date.now() - task.startTime}`,
             '</usage>',
             '</task-notification>',
         ].join('\n');

package/dist/cli/agents-dashboard.d.ts

@@ -1,4 +1,6 @@
+import { type ReactElement } from 'react';
 import type { TopLevelAgentSummary } from '../application/top-level-agent-manager.js';
+import { type TuiThemeSettings } from './tui/theme.js';
 export interface AgentsDashboardManager {
     launch(options: {
         prompt: string;
@@ -33,5 +35,12 @@ export declare function runAgentsDashboard(options: {
     manager: AgentsDashboardManager;
     defaults: AgentsDashboardDefaults;
     signal?: AbortSignal;
+}, dependencies?: {
+    loadThemeSettings?: () => Promise<TuiThemeSettings>;
+    renderDashboard?: (element: ReactElement, options: {
+        exitOnCtrlC: boolean;
+    }) => {
+        waitUntilExit(): Promise<void>;
+    };
 }): Promise<number>;
 //# sourceMappingURL=agents-dashboard.d.ts.map

package/dist/cli/agents-dashboard.js

@@ -1,6 +1,8 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { useCallback, useEffect, useRef, useState } from 'react';
+import { useCallback, useEffect, useRef, useState, } from 'react';
 import { Box, Text, render, useApp, useInput } from 'ink';
+import { loadTuiThemeSettings } from './tui/theme-settings.js';
+import { DEFAULT_TUI_THEME_SETTINGS, TuiThemeProvider, useTuiPalette, } from './tui/theme.js';
 const DASHBOARD_SECTIONS = [
     'Ready for review',
     'Needs input',
@@ -72,10 +74,12 @@ function groupAgents(agents) {
     return DASHBOARD_SECTIONS.flatMap((section) => agents.filter((agent) => sectionFor(agent) === section));
 }
 function AgentSection({ title, agents, selected, }) {
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { bold: true, children: [title, " (", agents.length, ")"] }), agents.length === 0 ? (_jsx(Text, { dimColor: true, children: " None" })) : (agents.map((agent) => (_jsxs(Text, { ...(agent === selected ? { color: 'cyan' } : {}), children: [agent === selected ? '› ' : '  ', agent.name, " \u00B7 ", agentStatus(agent), " \u00B7 ", agentKey(agent)] }, agentKey(agent)))))] }));
+    const palette = useTuiPalette();
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { bold: true, children: [title, " (", agents.length, ")"] }), agents.length === 0 ? (_jsx(Text, { dimColor: true, children: " None" })) : (agents.map((agent) => (_jsxs(Text, { ...(agent === selected ? { color: palette.accent } : {}), children: [agent === selected ? '› ' : '  ', agent.name, " \u00B7 ", agentStatus(agent), " \u00B7 ", agentKey(agent)] }, agentKey(agent)))))] }));
 }
 export function AgentsDashboardApp({ manager, defaults, signal, refreshIntervalMs = 1_000, onCancel, }) {
     const { exit } = useApp();
+    const palette = useTuiPalette();
     const [agents, setAgents] = useState([]);
     const [selectedIndex, setSelectedIndex] = useState(0);
     const selectedIndexRef = useRef(0);
@@ -410,14 +414,21 @@ export function AgentsDashboardApp({ manager, defaults, signal, refreshIntervalM
         editInput();
     });
     const selected = agents[selectedIndex];
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: "cyan", children: "Praxis agents" }), _jsxs(Text, { dimColor: true, children: [agents.length, " sessions \u00B7 live refresh"] }), DASHBOARD_SECTIONS.map((title) => (_jsx(AgentSection, { title: title, agents: agents.filter((agent) => sectionFor(agent) === title), ...(selected === undefined ? {} : { selected }) }, title))), mode === 'attach' ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: ["Attached to ", attachedId] }), attachedOutput ? (_jsx(Text, { children: attachedOutput })) : (_jsx(Text, { dimColor: true, children: "Waiting for output\u2026" })), _jsxs(Text, { children: ["\u203A ", input] }), _jsx(Text, { dimColor: true, children: "Enter sends \u00B7 Esc detaches \u00B7 Ctrl+C exits" })] })) : mode === 'review' ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: ["Reviewing ", reviewAgent ? agentKey(reviewAgent) : ''] }), _jsx(Text, { children: attachedOutput || 'No review output.' }), _jsxs(Text, { children: ["\u203A ", input] }), _jsx(Text, { dimColor: true, children: "Enter resumes with prompt \u00B7 Esc returns to list" })] })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: ["\u203A ", input || 'describe a task for a new background agent'] }), _jsx(Text, { dimColor: true, children: "Enter dispatches \u00B7 \u2191/\u2193 select \u00B7 Enter empty attaches \u00B7 Ctrl+X stops \u00B7 Ctrl+R refreshes \u00B7 ? help \u00B7 Esc exits" }), selected ? (_jsxs(Text, { dimColor: true, children: ["Selected ", agentKey(selected)] })) : null] })), busy ? _jsx(Text, { dimColor: true, children: "Working\u2026" }) : null, notice ? _jsx(Text, { color: "yellow", children: notice }) : null, showHelp ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Shortcuts" }), _jsx(Text, { children: "Enter dispatches or attaches \u00B7 Esc detaches/exits \u00B7 Ctrl+X stops local background agents \u00B7 Ctrl+R refreshes \u00B7 ? closes help" })] })) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: palette.accent, children: "Praxis agents" }), _jsxs(Text, { dimColor: true, children: [agents.length, " sessions \u00B7 live refresh"] }), DASHBOARD_SECTIONS.map((title) => (_jsx(AgentSection, { title: title, agents: agents.filter((agent) => sectionFor(agent) === title), ...(selected === undefined ? {} : { selected }) }, title))), mode === 'attach' ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: ["Attached to ", attachedId] }), attachedOutput ? (_jsx(Text, { children: attachedOutput })) : (_jsx(Text, { dimColor: true, children: "Waiting for output\u2026" })), _jsxs(Text, { children: ["\u203A ", input] }), _jsx(Text, { dimColor: true, children: "Enter sends \u00B7 Esc detaches \u00B7 Ctrl+C exits" })] })) : mode === 'review' ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: ["Reviewing ", reviewAgent ? agentKey(reviewAgent) : ''] }), _jsx(Text, { children: attachedOutput || 'No review output.' }), _jsxs(Text, { children: ["\u203A ", input] }), _jsx(Text, { dimColor: true, children: "Enter resumes with prompt \u00B7 Esc returns to list" })] })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: ["\u203A ", input || 'describe a task for a new background agent'] }), _jsx(Text, { dimColor: true, children: "Enter dispatches \u00B7 \u2191/\u2193 select \u00B7 Enter empty attaches \u00B7 Ctrl+X stops \u00B7 Ctrl+R refreshes \u00B7 ? help \u00B7 Esc exits" }), selected ? (_jsxs(Text, { dimColor: true, children: ["Selected ", agentKey(selected)] })) : null] })), busy ? _jsx(Text, { dimColor: true, children: "Working\u2026" }) : null, notice ? _jsx(Text, { color: palette.warning, children: notice }) : null, showHelp ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Shortcuts" }), _jsx(Text, { children: "Enter dispatches or attaches \u00B7 Esc detaches/exits \u00B7 Ctrl+X stops local background agents \u00B7 Ctrl+R refreshes \u00B7 ? closes help" })] })) : null] }));
 }
-export async function runAgentsDashboard(options) {
+export async function runAgentsDashboard(options, dependencies = {}) {
     const controller = new AbortController();
     const signal = options.signal
         ? AbortSignal.any([options.signal, controller.signal])
         : controller.signal;
-    const instance = render(_jsx(AgentsDashboardApp, { manager: options.manager, defaults: options.defaults, signal: signal, onCancel: () => controller.abort() }), { exitOnCtrlC: false });
+    let settings = DEFAULT_TUI_THEME_SETTINGS;
+    try {
+        settings = await (dependencies.loadThemeSettings ?? loadTuiThemeSettings)();
+    }
+    catch {
+        // A corrupt shared settings file must not make the standalone dashboard unusable.
+    }
+    const instance = (dependencies.renderDashboard ?? render)(_jsx(TuiThemeProvider, { settings: settings, children: _jsx(AgentsDashboardApp, { manager: options.manager, defaults: options.defaults, signal: signal, onCancel: () => controller.abort() }) }), { exitOnCtrlC: false });
     await instance.waitUntilExit();
     return signal.aborted ? 130 : 0;
 }