praxis-agent 0.7.0 → 0.9.0

package/README.md

@@ -92,6 +92,14 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   context/status/skill/task dashboards, prompt stash and continuation shortcuts,
   filterable `@` file and agent references, composer undo, `Ctrl+G` external
   editing, shared `/keybindings` creation/editing and supported-action remapping,
+  shared built-in and Claude-compatible custom `/theme` profiles with immediate
+  semantic recoloring, token editing/reset, deletion, and persisted syntax
+  toggles across transcript code and diff views,
+  shared runtime preferences for reduced motion, spinner tips, progress and
+  turn-duration display, editor mode, recap, notifications, auto-update channel,
+  gitignore-aware file references, and configurable AskUserQuestion timeouts,
+  provider-free `/terminal-setup` diagnostics and repeatable Shift+Enter setup
+  for supported local terminals,
   `Ctrl+V` text/image clipboard paste, `Ctrl+Z` shell suspension and `fg`
   recovery, permission-gated `!` shell turns, navigable current/per-turn Git
   diff views, rich decision panels, and measured context budgets; print mode,

package/dist/application/background-agent-manager.d.ts

@@ -30,6 +30,10 @@ export interface BackgroundAgentSnapshot {
     outputFile: string;
     result: BackgroundAgentRunResult | null;
     error: string | null;
+    name: string | null;
+    description: string;
+    startedAt: number;
+    durationMs: number | null;
 }
 export declare class BackgroundAgentManager {
     private readonly tasks;
@@ -39,6 +43,7 @@ export declare class BackgroundAgentManager {
     registerCompleted(spec: BackgroundAgentTaskSpec, result: BackgroundAgentRunResult): BackgroundAgentSnapshot;
     has(agentId: string): boolean;
     snapshotById(agentId: string): BackgroundAgentSnapshot | null;
+    snapshots(): readonly BackgroundAgentSnapshot[];
     output(agentId: string, options: {
         block: boolean;
         timeout: number;

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

@@ -62,6 +62,8 @@ export class BackgroundAgentManager {
             notifications: [],
             generation: 0,
             queuedMessages: [],
+            startedAt: Date.now(),
+            durationMs: null,
         };
         this.tasks.set(spec.agentId, task);
         this.start(task, spec.prompt, false, spec.toolUseId);
@@ -91,6 +93,8 @@ export class BackgroundAgentManager {
             notifications: [],
             generation: 0,
             queuedMessages: [],
+            startedAt: Date.now() - result.durationMs,
+            durationMs: result.durationMs,
         };
         this.tasks.set(spec.agentId, task);
         return this.snapshot(task);
@@ -102,6 +106,11 @@ export class BackgroundAgentManager {
         const task = this.tasks.get(agentId);
         return task ? this.snapshot(task) : null;
     }
+    snapshots() {
+        return [...this.tasks.values()]
+            .sort((left, right) => right.startedAt - left.startedAt)
+            .map((task) => this.snapshot(task));
+    }
     async output(agentId, options) {
         agentId = this.resolveRequired(agentId);
         if (!Number.isFinite(options.timeout) ||
@@ -132,6 +141,7 @@ export class BackgroundAgentManager {
         }
         task.status = 'stopped';
         task.error = 'Stopped by TaskStop';
+        task.durationMs ??= Date.now() - task.startedAt;
         task.queuedMessages.length = 0;
         task.controller.abort();
         return `Task ${agentId} stopped successfully`;
@@ -208,6 +218,8 @@ export class BackgroundAgentManager {
         const generation = task.generation;
         const controller = new AbortController();
         task.status = 'running';
+        task.startedAt = Date.now();
+        task.durationMs = null;
         task.controller = controller;
         task.result = null;
         task.error = null;
@@ -222,6 +234,7 @@ export class BackgroundAgentManager {
             }
             task.status = 'completed';
             task.result = result;
+            task.durationMs = result.durationMs;
             task.error = null;
             task.notifications.push({
                 status: 'completed',
@@ -237,8 +250,11 @@ export class BackgroundAgentManager {
                 this.finishStopped(task, error instanceof BackgroundAgentRunError ? error.result : undefined);
                 return;
             }
+            const failedResult = error instanceof BackgroundAgentRunError ? error.result : undefined;
             task.status = 'failed';
             task.result = null;
+            task.durationMs =
+                failedResult?.durationMs ?? Date.now() - task.startedAt;
             task.error = error instanceof Error ? error.message : String(error);
             task.notifications.push({
                 status: 'failed',
@@ -279,6 +295,7 @@ export class BackgroundAgentManager {
             durationMs: 0,
         };
         task.result = stoppedResult;
+        task.durationMs ??= stoppedResult.durationMs || Date.now() - task.startedAt;
         task.notifications.push({
             status: 'stopped',
             result: stoppedResult,
@@ -303,6 +320,10 @@ export class BackgroundAgentManager {
             outputFile: task.spec.outputFile,
             result: task.result,
             error: task.error,
+            name: task.spec.name ?? null,
+            description: task.spec.description,
+            startedAt: task.startedAt,
+            durationMs: task.durationMs,
         };
     }
     formatOutput(task) {

package/dist/application/background-bash-manager.d.ts

@@ -1,4 +1,16 @@
 import type { RuntimeEventSink } from '../core/runtime.js';
+export type BackgroundBashStatus = 'running' | 'completed' | 'failed' | 'stopped';
+export interface BackgroundBashSnapshot {
+    taskId: string;
+    status: BackgroundBashStatus;
+    command: string;
+    description: string;
+    outputFile: string;
+    output: string;
+    exitCode: number | null;
+    startedAt: number;
+    durationMs: number | null;
+}
 export interface BackgroundBashManagerOptions {
     cwd: string;
     cwdProvider?: () => string;
@@ -30,6 +42,7 @@ export declare class BackgroundBashManager {
     private readonly sessionStateRoot;
     constructor(options: BackgroundBashManagerOptions);
     has(taskId: string): boolean;
+    snapshots(): Promise<readonly BackgroundBashSnapshot[]>;
     launch(input: BackgroundBashLaunchInput): Promise<{
         taskId: string;
         outputFile: string;
@@ -50,5 +63,6 @@ export declare class BackgroundBashManager {
     private resolveTask;
     private hydratePersistedTasks;
     private persist;
+    private snapshot;
 }
 //# sourceMappingURL=background-bash-manager.d.ts.map

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

@@ -1,4 +1,4 @@
-import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { sanitizeClaudeProjectPath } from '../compatibility/claude/paths.js';
 import { writeFileAtomically } from '../platform/atomic-write.js';
@@ -32,7 +32,15 @@ function parsePersistedTask(source, taskId, outputFile) {
         !['completed', 'failed', 'stopped'].includes(String(task.status)) ||
         typeof task.output !== 'string' ||
         (task.exitCode !== null && !Number.isSafeInteger(task.exitCode)) ||
-        typeof task.notified !== 'boolean') {
+        typeof task.notified !== 'boolean' ||
+        (task.startedAt !== undefined &&
+            (typeof task.startedAt !== 'number' ||
+                !Number.isSafeInteger(task.startedAt) ||
+                task.startedAt < 0)) ||
+        (task.durationMs !== undefined &&
+            (typeof task.durationMs !== 'number' ||
+                !Number.isSafeInteger(task.durationMs) ||
+                task.durationMs < 0))) {
         return null;
     }
     return task;
@@ -63,6 +71,12 @@ export class BackgroundBashManager {
     has(taskId) {
         return this.tasks.has(taskId);
     }
+    async snapshots() {
+        await this.hydratePersistedTasks();
+        return [...this.tasks.values()]
+            .sort((left, right) => right.startedAt - left.startedAt)
+            .map((task) => this.snapshot(task));
+    }
     async launch(input) {
         await Promise.all([
             mkdir(this.outputRoot, { recursive: true }),
@@ -87,6 +101,7 @@ export class BackgroundBashManager {
             controller,
             completion: Promise.resolve(),
             startedAt: Date.now(),
+            durationMs: null,
             ...(input.signal
                 ? {
                     parentSignal: input.signal,
@@ -220,6 +235,7 @@ export class BackgroundBashManager {
                 task.exitCode = 1;
                 task.output = `Background task failed: ${error instanceof Error ? error.message : String(error)}`;
             }
+            task.durationMs = Date.now() - task.startedAt;
             await writeFile(task.outputFile, task.output, { mode: 0o600 }).catch(() => undefined);
             await this.persist(task).catch((persistError) => {
                 task.output = `${task.output}${task.output ? '\n' : ''}Failed to persist background task: ${persistError instanceof Error
@@ -260,6 +276,7 @@ export class BackgroundBashManager {
         task.output = result.output;
         task.exitCode = result.code;
         task.status = result.code === 0 && !result.timedOut ? 'completed' : 'failed';
+        task.durationMs = Date.now() - task.startedAt;
     }
     outputResult(task, retrievalOverride) {
         const retrievalStatus = retrievalOverride ?? (task.status === 'running' ? 'not_ready' : 'success');
@@ -299,14 +316,20 @@ export class BackgroundBashManager {
         if (existing)
             return existing;
         try {
-            const state = parsePersistedTask(await readFile(resolve(this.sessionStateRoot, `${taskId}.json`), 'utf8'), taskId, resolve(this.outputRoot, `${taskId}.output`));
+            const stateFile = resolve(this.sessionStateRoot, `${taskId}.json`);
+            const [source, metadata] = await Promise.all([
+                readFile(stateFile, 'utf8'),
+                stat(stateFile),
+            ]);
+            const state = parsePersistedTask(source, taskId, resolve(this.outputRoot, `${taskId}.output`));
             if (!state)
                 return null;
             const task = {
                 ...state,
                 controller: new AbortController(),
                 completion: Promise.resolve(),
-                startedAt: Date.now(),
+                startedAt: state.startedAt ?? Math.floor(metadata.mtimeMs),
+                durationMs: state.durationMs ?? null,
             };
             this.tasks.set(taskId, task);
             return task;
@@ -347,8 +370,23 @@ export class BackgroundBashManager {
             output: task.output,
             exitCode: task.exitCode,
             notified: task.notified,
+            startedAt: task.startedAt,
+            ...(task.durationMs === null ? {} : { durationMs: task.durationMs }),
         };
         await writeFileAtomically(resolve(this.sessionStateRoot, `${task.taskId}.json`), JSON.stringify(state, null, 2), { mode: 0o600 });
     }
+    snapshot(task) {
+        return {
+            taskId: task.taskId,
+            status: task.status,
+            command: task.command,
+            description: task.description,
+            outputFile: task.outputFile,
+            output: task.output,
+            exitCode: task.exitCode,
+            startedAt: task.startedAt,
+            durationMs: task.durationMs,
+        };
+    }
 }
 //# sourceMappingURL=background-bash-manager.js.map

package/dist/application/background-task-runtime.d.ts

@@ -0,0 +1,34 @@
+import type { BackgroundAgentSnapshot } from './background-agent-manager.js';
+import type { BackgroundBashSnapshot, BackgroundBashToolResult } from './background-bash-manager.js';
+import type { WorkflowTaskSnapshot } from './workflow-manager.js';
+export interface BackgroundTaskSnapshot {
+    shells: readonly BackgroundBashSnapshot[];
+    agents: readonly BackgroundAgentSnapshot[];
+    workflows: readonly WorkflowTaskSnapshot[];
+}
+export interface BackgroundBashTaskSource {
+    backgroundSnapshots(): Promise<readonly BackgroundBashSnapshot[]>;
+    stopBackgroundTask(taskId: string): Promise<BackgroundBashToolResult>;
+}
+export interface BackgroundAgentTaskSource {
+    backgroundSnapshots(): readonly BackgroundAgentSnapshot[];
+    stopBackgroundTask(taskId: string): string;
+}
+export interface WorkflowTaskSource {
+    list(sessionId?: string): readonly WorkflowTaskSnapshot[];
+    hasForSession(sessionId: string, taskId: string): boolean;
+    stopAndWait(taskId: string): Promise<void>;
+}
+/** Aggregates the actual task owners created across turns of one CLI session. */
+export declare class BackgroundTaskRuntime {
+    private readonly workflows;
+    private readonly bashSources;
+    private readonly agentSources;
+    constructor(workflows: WorkflowTaskSource | null);
+    registerBash(sessionId: string, source: BackgroundBashTaskSource): void;
+    registerAgents(sessionId: string, source: BackgroundAgentTaskSource): void;
+    snapshot(sessionId: string): Promise<BackgroundTaskSnapshot>;
+    stop(sessionId: string, taskId: string): Promise<void>;
+    clear(): void;
+}
+//# sourceMappingURL=background-task-runtime.d.ts.map

package/dist/application/background-task-runtime.js

@@ -0,0 +1,59 @@
+function uniqueById(values, id) {
+    return [...new Map(values.map((value) => [id(value), value])).values()];
+}
+function addSource(sources, sessionId, value) {
+    const existing = sources.get(sessionId);
+    if (existing)
+        existing.add(value);
+    else
+        sources.set(sessionId, new Set([value]));
+}
+/** Aggregates the actual task owners created across turns of one CLI session. */
+export class BackgroundTaskRuntime {
+    workflows;
+    bashSources = new Map();
+    agentSources = new Map();
+    constructor(workflows) {
+        this.workflows = workflows;
+    }
+    registerBash(sessionId, source) {
+        addSource(this.bashSources, sessionId, source);
+    }
+    registerAgents(sessionId, source) {
+        addSource(this.agentSources, sessionId, source);
+    }
+    async snapshot(sessionId) {
+        const shellGroups = await Promise.all([...(this.bashSources.get(sessionId) ?? [])].map((source) => source.backgroundSnapshots()));
+        return {
+            shells: uniqueById(shellGroups.flat(), ({ taskId }) => taskId),
+            agents: uniqueById([...(this.agentSources.get(sessionId) ?? [])].flatMap((source) => source.backgroundSnapshots()), ({ agentId }) => agentId),
+            workflows: uniqueById(this.workflows?.list(sessionId) ?? [], ({ task_id: taskId }) => taskId),
+        };
+    }
+    async stop(sessionId, taskId) {
+        for (const source of this.bashSources.get(sessionId) ?? []) {
+            if (!(await source.backgroundSnapshots()).some(({ taskId: id }) => id === taskId)) {
+                continue;
+            }
+            await source.stopBackgroundTask(taskId);
+            return;
+        }
+        for (const source of this.agentSources.get(sessionId) ?? []) {
+            if (!source.backgroundSnapshots().some(({ agentId }) => agentId === taskId)) {
+                continue;
+            }
+            source.stopBackgroundTask(taskId);
+            return;
+        }
+        if (this.workflows?.hasForSession(sessionId, taskId)) {
+            await this.workflows.stopAndWait(taskId);
+            return;
+        }
+        throw new Error(`No task found with ID: ${taskId}`);
+    }
+    clear() {
+        this.bashSources.clear();
+        this.agentSources.clear();
+    }
+}
+//# sourceMappingURL=background-task-runtime.js.map

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

@@ -2,6 +2,7 @@ import type { ClaudeConditionalRuleResolver } from '../compatibility/claude/cont
 import { type ClaudeFileResource, type ClaudeFileResourceConfig } from '../compatibility/claude/file-resources.js';
 import { type ClaudeDisplayTranscriptItem } from '../compatibility/claude/projection.js';
 import { type ModelDocument, type ModelImage, type ModelToolCall, type ModelProvider, type ModelUsage, type PermissionApproval, type PermissionResolver, type RuntimeEventSink, type ToolRegistry } from '../core/runtime.js';
+import { type BackgroundTaskSnapshot } from './background-task-runtime.js';
 import type { ModelPricingRegistry } from '../core/usage.js';
 import type { Compactor } from '../core/compaction.js';
 import { ContextBudget } from '../core/context-budget.js';
@@ -10,9 +11,11 @@ import type { ClaudeExtensionCatalog } from '../extensions/claude-extensions.js'
 import type { ClaudeHookRunner } from '../hooks/claude-hooks.js';
 import { type TranscriptParseIssue } from '../persistence/claude-transcript-store.js';
 import { type AgentPermissionMode } from './subagent-service.js';
+import { type WorkflowTaskSnapshot } from './workflow-manager.js';
 import type { WorkspaceContext } from './session-worktree.js';
 import type { ClaudeInteractiveToolManager } from '../tools/claude-interactive-tools.js';
 import type { ClaudePermissionMode } from '../permissions/claude-permission-resolver.js';
+import type { ClaudeMcpRuntime, ClaudeMcpServerStatus, ClaudeMcpToolInspection } from '../mcp/claude-mcp-tools.js';
 export interface ClaudeSessionServiceOptions {
     configRoot: string;
     cwd: string;
@@ -55,11 +58,15 @@ export interface ClaudeSessionServiceOptions {
     initialWorktreeName?: string;
     enableWorktrees?: boolean;
     worktreeToolNames?: readonly ('EnterWorktree' | 'ExitWorktree')[];
+    worktreeBaseRef?: 'fresh' | 'head';
     fileResources?: readonly ClaudeFileResource[];
     fileResourceConfig?: Omit<ClaudeFileResourceConfig, 'sessionId' | 'signal'>;
     fileCheckpointing?: boolean;
+    /** Disable only automatic context compaction; manual /compact remains available. */
+    autoCompact?: boolean;
     fileRewindRoots?: readonly string[];
     interactiveTools?: ClaudeInteractiveToolManager;
+    mcp?: ClaudeMcpRuntime;
 }
 export interface SessionRunResult {
     sessionId: string;
@@ -133,16 +140,26 @@ export declare class ClaudeSessionService {
     private readonly inMemoryStores;
     private readonly scheduledPrompts;
     private readonly workflowManager;
+    private readonly backgroundTasks;
     private readonly worktreeManager;
     private readonly sessionCwds;
     private readonly hostedSubagents;
     private readonly hostedSubagentsByRegistry;
     private readonly backgroundNotificationWrites;
     private readonly downloadedFileResourceSessions;
+    private mcpClosePromise;
     private runtimeCwd;
     constructor(options: ClaudeSessionServiceOptions);
     nextScheduledPrompt(signal?: AbortSignal): Promise<import("./scheduled-prompt-manager.js").ScheduledPrompt | null>;
-    workflows(): readonly Record<string, unknown>[];
+    workflows(): readonly WorkflowTaskSnapshot[];
+    mcpInspect(): Promise<readonly ClaudeMcpServerStatus[]>;
+    mcpReconnect(name: string): Promise<void>;
+    mcpAuthenticate(name: string): Promise<void>;
+    mcpReload(): Promise<void>;
+    mcpTools(name: string): Promise<readonly ClaudeMcpToolInspection[]>;
+    private requireMcp;
+    taskSnapshots(sessionId: string): Promise<BackgroundTaskSnapshot>;
+    stopTask(sessionId: string, taskId: string): Promise<void>;
     close(): Promise<void>;
     createHostedToolRegistry(sessionId: string): ToolRegistry;
     run(prompt: string, signal?: AbortSignal, sessionId?: string, name?: string, images?: readonly ModelImage[], documents?: readonly ModelDocument[]): Promise<SessionRunResult>;
@@ -160,6 +177,8 @@ export declare class ClaudeSessionService {
     rename(sessionId: string, name: string): Promise<void>;
     changeCwd(sessionId: string | undefined, requestedCwd: string): Promise<string>;
     recordCdUsage(sessionId: string): Promise<void>;
+    approveRecentlyDenied(sessionId: string, display: string): Promise<void>;
+    retryRecentlyDenied(sessionId: string, display: string, signal?: AbortSignal): Promise<SessionRunResult>;
     recordBtwUsage(sessionId: string | undefined, permissionMode?: ClaudePermissionMode): Promise<string>;
     recordBackgroundUsage(sessionId: string | undefined, permissionMode?: ClaudePermissionMode): Promise<string>;
     recordBackgroundLaunch(sessionId: string): Promise<SessionForkCheckpoint>;
@@ -188,6 +207,7 @@ export declare class ClaudeSessionService {
     private appendSystemLocalCommand;
     private ensureLocalSession;
     private appendInputHistory;
+    private appendPermissionGrant;
     private appendBackgroundNotification;
     private enqueueBackgroundNotifications;
     private cdCommandEntries;