praxis-agent 0.19.0 → 0.20.1

package/dist/cli/interactive.d.ts

@@ -14,7 +14,7 @@ import type { AgentColorName } from '../compatibility/claude/agent-color.js';
 import type { ClaudeResourceScope } from '../compatibility/claude/shared-resources.js';
 import type { TuiHookConfiguration } from './tui/hook-settings.js';
 import { type TuiSlashCommand } from './tui/slash-commands.js';
-import { type DoctorReport } from '../maintenance/doctor.js';
+import { type DoctorProgressListener, type DoctorReport } from '../maintenance/doctor.js';
 import { type TuiAgentEntry, type TuiFileEntry } from './tui/file-picker.js';
 import { type TuiEditorOptions, type TuiEditorResult } from './tui/external-editor.js';
 import { type TuiClipboardContent } from './tui/clipboard.js';
@@ -135,7 +135,7 @@ interface InteractiveAppProps {
     allowDangerouslySkipPermissions?: boolean;
     additionalDirectories?: readonly string[];
     diffLoader?: () => Promise<TuiDiffSnapshot>;
-    doctorLoader?: () => Promise<DoctorReport>;
+    doctorLoader?: (onProgress?: DoctorProgressListener) => Promise<DoctorReport>;
     fileLoader?: () => Promise<readonly TuiFileEntry[]>;
     externalEditor?: (prompt: string, options: TuiEditorOptions) => Promise<TuiEditorResult>;
     keybindingsConfigRoot?: string;

package/dist/cli/interactive.js

@@ -20,7 +20,7 @@ import { addTuiPermissionRule, loadTuiPermissionRules, removeTuiPermissionRule,
 import { createRecentlyDeniedStore, } from './tui/recently-denied.js';
 import { agentColorMessage, parseAgentColorInput, } from '../compatibility/claude/agent-color.js';
 import { filterTuiSlashCommands, mergeTuiSlashCommands, slashCommandQuery, } from './tui/slash-commands.js';
-import { runDoctor } from '../maintenance/doctor.js';
+import { runDoctor, } from '../maintenance/doctor.js';
 import { canonicalClaudeCostModelName, formatCostSummary, } from './tui/cost-summary.js';
 import { createComposerEditor, deleteComposerBackward, deleteComposerForward, deleteComposerToEnd, deleteComposerToStart, deleteComposerWordBackward, insertComposerText, moveComposerCursor, moveComposerCursorByWord, } from './tui/composer-editor.js';
 import { applyMentionReference, fileReferenceAtCursor, filterTuiMentionEntries, loadTuiFileEntries, } from './tui/file-picker.js';
@@ -274,7 +274,7 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
     const runtimeGitignoreRef = useRef(true);
     const loadDiffSnapshot = useMemo(() => diffLoader ?? (() => loadGitDiff(runtimeCwd)), [diffLoader, runtimeCwd]);
     const loadDoctorReport = useMemo(() => doctorLoader ??
-        (async () => {
+        (async (onProgress) => {
             const configuredRoot = process.env.CLAUDE_CONFIG_DIR || undefined;
             const configRoot = resolve(configuredRoot ?? resolve(homedir(), '.claude'));
             const claudeStatePath = configuredRoot
@@ -295,6 +295,7 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
                 ...(process.argv[1] === undefined
                     ? {}
                     : { invokedBinaryPath: process.argv[1] }),
+                ...(onProgress === undefined ? {} : { onProgress }),
             });
         }), [doctorLoader, runtimeCwd, display.version, configTarget]);
     const loadFiles = useMemo(() => fileLoader ??
@@ -1849,7 +1850,18 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
         const loading = (async () => {
             setBusy(true);
             try {
-                const report = await loadDoctorReport();
+                const report = await loadDoctorReport((progress) => {
+                    const current = menuRef.current;
+                    if (current?.kind === 'doctor' && current.generation === generation) {
+                        updateMenu({
+                            kind: 'doctor',
+                            generation,
+                            loading: false,
+                            report: progress,
+                            error: null,
+                        });
+                    }
+                });
                 const current = menuRef.current;
                 if (current?.kind === 'doctor' && current.generation === generation) {
                     updateMenu({

package/dist/cli/tui/doctor-dashboard.d.ts

@@ -1,13 +1,13 @@
 import React from 'react';
-import type { DoctorCheck, DoctorReport } from '../../maintenance/doctor.js';
+import type { DoctorCheck, DoctorProgressReport, DoctorReport } from '../../maintenance/doctor.js';
 export interface DoctorWarningGroup {
     heading: string;
     checks: readonly DoctorCheck[];
 }
-export declare function projectDoctorWarningGroups(report: DoctorReport): readonly DoctorWarningGroup[];
+export declare function projectDoctorWarningGroups(report: DoctorReport | DoctorProgressReport): readonly DoctorWarningGroup[];
 export declare function DoctorDashboard({ loading, report, error, width, screenReader, }: {
     loading: boolean;
-    report: DoctorReport | null;
+    report: DoctorReport | DoctorProgressReport | null;
     error: string | null;
     width: number;
     screenReader: boolean;

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

@@ -77,6 +77,6 @@ export function DoctorDashboard({ loading, report, error, width, screenReader, }
     if (report === null)
         return null;
     const { diagnostic, updates } = report;
-    return (_jsxs(Box, { flexDirection: "column", width: Math.min(100, width), children: [_jsx(Text, { bold: true, children: " Doctor:" }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: " Diagnostics" }), _jsx(Text, { children: `Currently running: Praxis ${diagnostic.version} (${diagnostic.installationType})` }), diagnostic.packageManager !== null && (_jsx(Text, { children: `Package manager: ${diagnostic.packageManager}` })), _jsx(Text, { children: `Path: ${diagnostic.installationPath}` }), _jsx(Text, { children: `Invoked: ${diagnostic.invokedBinary}` }), _jsx(Text, { children: `Config install method: ${diagnostic.configInstallMethod}` }), diagnostic.search.working ? (_jsxs(_Fragment, { children: [_jsx(Text, { children: `Search: OK (${diagnostic.search.mode})` }), diagnostic.search.systemPath !== null && (_jsx(Text, { children: `└ ${diagnostic.search.systemPath}` }))] })) : (_jsx(Text, { children: "Search: unavailable" })), diagnostic.multipleInstallations.length > 1 && (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: "Multiple installations found" }), diagnostic.multipleInstallations.map((path) => (_jsx(Text, { children: `- ${path}` }, path)))] })), diagnostic.recommendation !== null && (_jsx(Text, { children: `Recommendation: ${diagnostic.recommendation}` })), diagnostic.warnings.map((warning) => (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: warning.issue }), _jsx(Text, { children: `└ Fix: ${warning.fix}` })] }, warning.issue))), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: " Updates" }), _jsx(Text, { children: `Auto-updates: ${updates.autoUpdates}` }), updates.hasUpdatePermissions !== null && (_jsx(Text, { children: `Update permissions: ${updates.hasUpdatePermissions ? 'yes' : 'no'}` })), _jsx(Text, { children: `Auto-update channel: ${updates.channel}` }), updates.registryStatus === 'available' ? (_jsxs(_Fragment, { children: [updates.stableVersion !== null && (_jsx(Text, { children: `Stable version: ${updates.stableVersion}` })), _jsx(Text, { children: `Latest version: ${updates.latestVersion ?? 'unknown'}` })] })) : (_jsx(Text, { children: "\u2514 Failed to fetch versions" })), _jsx(WarningGroups, { report: report, screenReader: screenReader }), _jsx(Text, { children: " " }), _jsx(Text, { children: doctorSummary(report) }), _jsx(Text, { children: `Summary: ${report.summary.passed} passed, ${report.summary.warnings} warnings, ${report.summary.failed} failed.` }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: footer })] }));
+    return (_jsxs(Box, { flexDirection: "column", width: Math.min(100, width), children: [_jsx(Text, { bold: true, children: " Doctor:" }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: " Diagnostics" }), _jsx(Text, { children: `Currently running: Praxis ${diagnostic.version} (${diagnostic.installationType})` }), diagnostic.packageManager !== null && (_jsx(Text, { children: `Package manager: ${diagnostic.packageManager}` })), _jsx(Text, { children: `Path: ${diagnostic.installationPath}` }), _jsx(Text, { children: `Invoked: ${diagnostic.invokedBinary}` }), _jsx(Text, { children: `Config install method: ${diagnostic.configInstallMethod}` }), diagnostic.search.working ? (_jsxs(_Fragment, { children: [_jsx(Text, { children: `Search: OK (${diagnostic.search.mode})` }), diagnostic.search.systemPath !== null && (_jsx(Text, { children: `└ ${diagnostic.search.systemPath}` }))] })) : (_jsx(Text, { children: "Search: unavailable" })), diagnostic.multipleInstallations.length > 1 && (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: "Multiple installations found" }), diagnostic.multipleInstallations.map((path) => (_jsx(Text, { children: `- ${path}` }, path)))] })), diagnostic.recommendation !== null && (_jsx(Text, { children: `Recommendation: ${diagnostic.recommendation}` })), diagnostic.warnings.map((warning) => (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: warning.issue }), _jsx(Text, { children: `└ Fix: ${warning.fix}` })] }, warning.issue))), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: " Updates" }), _jsx(Text, { children: `Auto-updates: ${updates.autoUpdates}` }), updates.hasUpdatePermissions !== null && (_jsx(Text, { children: `Update permissions: ${updates.hasUpdatePermissions ? 'yes' : 'no'}` })), _jsx(Text, { children: `Auto-update channel: ${updates.channel}` }), updates.registryStatus === 'available' ? (_jsxs(_Fragment, { children: [updates.stableVersion !== null && (_jsx(Text, { children: `Stable version: ${updates.stableVersion}` })), _jsx(Text, { children: `Latest version: ${updates.latestVersion ?? 'unknown'}` })] })) : updates.registryStatus === 'loading' ? (_jsx(Text, { children: "Checking for updates\u2026" })) : (_jsx(Text, { children: "\u2514 Failed to fetch versions" })), _jsx(WarningGroups, { report: report, screenReader: screenReader }), _jsx(Text, { children: " " }), _jsx(Text, { children: doctorSummary(report) }), _jsx(Text, { children: `Summary: ${report.summary.passed} passed, ${report.summary.warnings} warnings, ${report.summary.failed} failed.` }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: footer })] }));
 }
 //# sourceMappingURL=doctor-dashboard.js.map

package/dist/cli.js

@@ -31,6 +31,7 @@ import { ClaudeMcpToolRegistry, } from './mcp/claude-mcp-tools.js';
 import { ClaudeMcpManagement, filterDisabledMcpResources, mcpScope, } from './mcp/claude-mcp-management.js';
 import { authenticateMcpServer, ClaudeMcpOAuthStore, mcpOAuthServerIdentity, readMcpClientSecret, } from './mcp/claude-mcp-oauth.js';
 import { servePraxisMcpStdio } from './mcp/praxis-mcp-server.js';
+import { VERIFIED_CLAUDE_SCHEMA_VERSION } from './compatibility/claude/schema.js';
 import { detectInstalledClaudeVersion } from './platform/claude-version.js';
 import { redactSensitiveText, sensitiveEnvironmentValues, } from './platform/sensitive-data.js';
 import { AnthropicCompatibleProvider } from './providers/anthropic-compatible.js';
@@ -697,7 +698,7 @@ const consoleIO = {
 const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = false, approveRecovery, approveTool, agent, model: interactiveModel, effort: interactiveEffort, permissionMode: interactivePermissionMode, isSessionActionApproved, controls = DEFAULT_CLI_CONTROLS, interactive = false, sessionKind, signal, exposeToolRegistry = false, onElicitation, askUser, approvePlan, emitToolUseSummaries = false, cwd: requestedCwd, sandboxOriginalCwd, configRoot: requestedConfigRoot, environment, providerEnvironment: requestedProviderEnvironment, }) => {
     const runtimeEnvironment = requestedProviderEnvironment ?? process.env;
     const sandboxEnvironment = { ...runtimeEnvironment, ...environment };
-    const claudeVersion = await detectInstalledClaudeVersion();
+    const claudeVersion = VERIFIED_CLAUDE_SCHEMA_VERSION;
     const cwd = requestedCwd ?? process.cwd();
     const workspace = new WorkspaceContext(cwd);
     const configuredRoot = runtimeEnvironment.CLAUDE_CONFIG_DIR || undefined;
@@ -4436,8 +4437,14 @@ function isDirectExecution(moduleUrl, argvPath) {
 if (isDirectExecution(import.meta.url, process.argv[1])) {
     const controller = new AbortController();
     const cancel = () => controller.abort();
-    process.once('SIGINT', cancel);
-    process.exitCode = await run(process.argv.slice(2), consoleIO, defaultDependencies, controller.signal);
-    process.removeListener('SIGINT', cancel);
+    process.on('SIGINT', cancel);
+    process.on('SIGTERM', cancel);
+    try {
+        process.exitCode = await run(process.argv.slice(2), consoleIO, defaultDependencies, controller.signal);
+    }
+    finally {
+        process.removeListener('SIGINT', cancel);
+        process.removeListener('SIGTERM', cancel);
+    }
 }
 //# sourceMappingURL=cli.js.map

package/dist/compatibility/claude/schema.d.ts

@@ -11,6 +11,7 @@ export interface ClaudeSchemaAdapter {
     serializeForSidechainAppend(entry: ClaudeTranscriptEntry): string;
     serializeForFork(entry: ClaudeTranscriptEntry): string;
 }
+export declare const VERIFIED_CLAUDE_SCHEMA_VERSION = "2.1.208";
 export declare function isClaudeForkableEntryType(type: string): boolean;
 export declare function copyClaudeEntryWithSessionId(entry: ClaudeTranscriptEntry, sessionId: string): ClaudeTranscriptEntry;
 export declare function selectClaudeSchemaAdapter(version: string): ClaudeSchemaAdapter;

package/dist/compatibility/claude/schema.js

@@ -1,5 +1,5 @@
 import { isAgentColorValue } from './agent-color.js';
-const SUPPORTED_VERSION = '2.1.208';
+export const VERIFIED_CLAUDE_SCHEMA_VERSION = '2.1.208';
 const APPENDABLE_ENTRY_TYPES = new Set([
     'agent-color',
     'agent-name',
@@ -775,8 +775,8 @@ function validateAppendableEntry(entry) {
             throw new Error(`Claude transcript entry is missing ${field}`);
         }
     }
-    if (entry.version !== SUPPORTED_VERSION) {
-        throw new Error(`Claude transcript append must target Claude Code ${SUPPORTED_VERSION}`);
+    if (entry.version !== VERIFIED_CLAUDE_SCHEMA_VERSION) {
+        throw new Error(`Claude transcript append must target Claude Code ${VERIFIED_CLAUDE_SCHEMA_VERSION}`);
     }
     if (!('parentUuid' in entry) ||
         (entry.parentUuid !== null && !isNonEmptyString(entry.parentUuid))) {
@@ -836,8 +836,8 @@ function validateSidechainEntry(entry) {
             throw new Error(`Claude sidechain entry is missing ${field}`);
         }
     }
-    if (entry.version !== SUPPORTED_VERSION) {
-        throw new Error(`Claude sidechain append must target Claude Code ${SUPPORTED_VERSION}`);
+    if (entry.version !== VERIFIED_CLAUDE_SCHEMA_VERSION) {
+        throw new Error(`Claude sidechain append must target Claude Code ${VERIFIED_CLAUDE_SCHEMA_VERSION}`);
     }
     if (!('parentUuid' in entry) ||
         (entry.parentUuid !== null && !isNonEmptyString(entry.parentUuid))) {
@@ -925,8 +925,8 @@ function validateForkableEntry(entry) {
             throw new Error(`Claude transcript entry is missing ${field}`);
         }
     }
-    if (entry.version !== SUPPORTED_VERSION) {
-        throw new Error(`Claude transcript fork must target Claude Code ${SUPPORTED_VERSION}`);
+    if (entry.version !== VERIFIED_CLAUDE_SCHEMA_VERSION) {
+        throw new Error(`Claude transcript fork must target Claude Code ${VERIFIED_CLAUDE_SCHEMA_VERSION}`);
     }
     if (!('parentUuid' in entry) ||
         (entry.parentUuid !== null && !isNonEmptyString(entry.parentUuid))) {
@@ -969,7 +969,7 @@ function validateForkableEntry(entry) {
         validateForkAssistantMessage(entry.message);
 }
 class ClaudeCode21208Adapter {
-    version = SUPPORTED_VERSION;
+    version = VERIFIED_CLAUDE_SCHEMA_VERSION;
     writeMode = 'read-write';
     parse(line) {
         return parseEntry(line);
@@ -1019,7 +1019,7 @@ class ReadOnlyClaudeAdapter {
     }
 }
 export function selectClaudeSchemaAdapter(version) {
-    if (version === SUPPORTED_VERSION) {
+    if (version === VERIFIED_CLAUDE_SCHEMA_VERSION) {
         return new ClaudeCode21208Adapter();
     }
     return new ReadOnlyClaudeAdapter(version);

package/dist/maintenance/doctor-diagnostic.d.ts

@@ -20,15 +20,22 @@ export interface DoctorInstallationDiagnostic {
     readonly multipleInstallations: readonly string[];
     readonly warnings: readonly DoctorDiagnosticWarning[];
 }
-export interface DoctorUpdateDiagnostic {
+export interface DoctorUpdateBaseDiagnostic {
     readonly autoUpdates: string;
     readonly hasUpdatePermissions: boolean | null;
     readonly channel: 'latest' | 'stable';
+}
+export interface DoctorUpdateDiagnostic extends DoctorUpdateBaseDiagnostic {
     readonly stableVersion: string | null;
     readonly latestVersion: string | null;
     readonly registryStatus: 'available' | 'unavailable';
     readonly error?: string;
 }
+export interface DoctorPendingUpdateDiagnostic extends DoctorUpdateBaseDiagnostic {
+    readonly stableVersion: null;
+    readonly latestVersion: null;
+    readonly registryStatus: 'loading';
+}
 export interface PraxisDistTags {
     stable?: string;
     latest?: string;
@@ -49,6 +56,12 @@ export interface DoctorDiagnosticsResult {
     diagnostic: DoctorInstallationDiagnostic;
     updates: DoctorUpdateDiagnostic;
 }
+export interface DoctorLocalDiagnosticsResult {
+    diagnostic: DoctorInstallationDiagnostic;
+    updates: DoctorPendingUpdateDiagnostic;
+}
 export declare function loadPraxisDistTags(): Promise<PraxisDistTags>;
+export declare function resolveDoctorUpdates(options: DoctorDiagnosticOptions, pendingUpdates: DoctorPendingUpdateDiagnostic): Promise<DoctorUpdateDiagnostic>;
+export declare function collectDoctorLocalDiagnostics(options: DoctorDiagnosticOptions): Promise<DoctorLocalDiagnosticsResult>;
 export declare function collectDoctorDiagnostics(options: DoctorDiagnosticOptions): Promise<DoctorDiagnosticsResult>;
 //# sourceMappingURL=doctor-diagnostic.d.ts.map

package/dist/maintenance/doctor-diagnostic.js

@@ -96,9 +96,21 @@ async function updatePermissions(directory) {
         return code === 'EACCES' || code === 'EPERM' ? false : null;
     }
 }
-async function buildUpdateDiagnostic(options, installation) {
+async function buildPendingUpdateDiagnostic(options, installation) {
     const checkUpdatePermissions = options.checkUpdatePermissions ?? updatePermissions;
     const hasUpdatePermissions = await checkUpdatePermissions(dirname(installation.invokedBinary));
+    return {
+        autoUpdates: installation.installationType === 'npm'
+            ? 'Manual (praxis update)'
+            : 'Managed by source checkout',
+        hasUpdatePermissions,
+        channel: options.autoUpdateChannel,
+        stableVersion: null,
+        latestVersion: null,
+        registryStatus: 'loading',
+    };
+}
+export async function resolveDoctorUpdates(options, pendingUpdates) {
     let stableVersion = null;
     let latestVersion = null;
     let registryStatus = 'unavailable';
@@ -120,18 +132,16 @@ async function buildUpdateDiagnostic(options, installation) {
         error = `${REGISTRY_ERROR}: ${cause instanceof Error ? cause.message : String(cause)}`;
     }
     return {
-        autoUpdates: installation.installationType === 'npm'
-            ? 'Manual (praxis update)'
-            : 'Managed by source checkout',
-        hasUpdatePermissions,
-        channel: options.autoUpdateChannel,
+        autoUpdates: pendingUpdates.autoUpdates,
+        hasUpdatePermissions: pendingUpdates.hasUpdatePermissions,
+        channel: pendingUpdates.channel,
         stableVersion,
         latestVersion,
         registryStatus,
         ...(error === undefined ? {} : { error }),
     };
 }
-export async function collectDoctorDiagnostics(options) {
+export async function collectDoctorLocalDiagnostics(options) {
     const installationPath = await readableExecutable(options.executablePath);
     const invokedBinary = resolve(options.invokedBinaryPath ?? options.executablePath);
     const installationType = installationPath
@@ -171,10 +181,15 @@ export async function collectDoctorDiagnostics(options) {
         multipleInstallations,
         warnings,
     };
-    const updates = await buildUpdateDiagnostic(options, {
+    const updates = await buildPendingUpdateDiagnostic(options, {
         installationType,
         invokedBinary,
     });
     return { diagnostic, updates };
 }
+export async function collectDoctorDiagnostics(options) {
+    const local = await collectDoctorLocalDiagnostics(options);
+    const updates = await resolveDoctorUpdates(options, local.updates);
+    return { diagnostic: local.diagnostic, updates };
+}
 //# sourceMappingURL=doctor-diagnostic.js.map

package/dist/maintenance/doctor.d.ts

@@ -1,5 +1,5 @@
 import { type VersionCommand } from '../platform/claude-version.js';
-import { type DoctorInstallationDiagnostic, type DoctorUpdateDiagnostic, type PraxisDistTagLoader } from './doctor-diagnostic.js';
+import { type DoctorInstallationDiagnostic, type DoctorPendingUpdateDiagnostic, type DoctorUpdateDiagnostic, type PraxisDistTagLoader } from './doctor-diagnostic.js';
 export interface DoctorCheck {
     id: 'installation' | 'node' | 'provider' | 'config-root' | 'settings' | 'plugins' | 'mcp' | 'permissions' | 'resources' | 'hooks' | 'claude-runtime';
     status: 'pass' | 'warn' | 'fail';
@@ -19,6 +19,10 @@ export interface DoctorReport {
         failed: number;
     };
 }
+export type DoctorProgressReport = Omit<DoctorReport, 'updates'> & {
+    updates: DoctorPendingUpdateDiagnostic;
+};
+export type DoctorProgressListener = (report: DoctorProgressReport) => void;
 export interface DoctorOptions {
     version: string;
     executablePath: string;
@@ -33,6 +37,7 @@ export interface DoctorOptions {
     autoUpdateChannel: 'latest' | 'stable';
     invokedBinaryPath?: string;
     loadDistTags?: PraxisDistTagLoader;
+    onProgress?: DoctorProgressListener;
 }
 export declare function runDoctor(options: DoctorOptions): Promise<DoctorReport>;
 export declare function formatDoctorReport(report: DoctorReport): string;

package/dist/maintenance/doctor.js

@@ -15,7 +15,7 @@ import { ContextBudget } from '../core/context-budget.js';
 import { ModelPricingRegistry } from '../core/usage.js';
 import { detectInstalledClaudeVersion, } from '../platform/claude-version.js';
 import { redactSensitiveText, sensitiveEnvironmentValues, } from '../platform/sensitive-data.js';
-import { collectDoctorDiagnostics, } from './doctor-diagnostic.js';
+import { collectDoctorLocalDiagnostics, resolveDoctorUpdates, } from './doctor-diagnostic.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -129,7 +129,7 @@ export async function runDoctor(options) {
     const configRoot = resolve(options.configRoot);
     const cwd = resolve(options.cwd);
     const sensitiveValues = sensitiveEnvironmentValues(options.environment);
-    const { diagnostic, updates } = await collectDoctorDiagnostics({
+    const diagnosticOptions = {
         version: options.version,
         executablePath: options.executablePath,
         ...(options.invokedBinaryPath === undefined
@@ -141,7 +141,9 @@ export async function runDoctor(options) {
         ...(options.loadDistTags === undefined
             ? {}
             : { loadDistTags: options.loadDistTags }),
-    });
+    };
+    const local = await collectDoctorLocalDiagnostics(diagnosticOptions);
+    const updatesPromise = resolveDoctorUpdates(diagnosticOptions, local.updates);
     let settings;
     const checks = [];
     checks.push(await capture('installation', async () => {
@@ -372,26 +374,28 @@ export async function runDoctor(options) {
             check.summary = redactSensitiveText(check.summary, sensitiveValues);
         }
     }
-    const reportUpdates = updates.error === undefined
-        ? updates
-        : {
-            ...updates,
-            error: redactSensitiveText(updates.error, sensitiveValues),
-        };
     const summary = {
         passed: checks.filter((check) => check.status === 'pass').length,
         warnings: checks.filter((check) => check.status === 'warn').length,
         failed: checks.filter((check) => check.status === 'fail').length,
     };
-    return {
+    const base = {
         type: 'doctor',
         ok: checks.every((check) => check.status !== 'fail'),
         praxisVersion: options.version,
-        diagnostic,
-        updates: reportUpdates,
+        diagnostic: local.diagnostic,
         checks,
         summary,
     };
+    options.onProgress?.({ ...base, updates: local.updates });
+    const updates = await updatesPromise;
+    const reportUpdates = updates.error === undefined
+        ? updates
+        : {
+            ...updates,
+            error: redactSensitiveText(updates.error, sensitiveValues),
+        };
+    return { ...base, updates: reportUpdates };
 }
 export function formatDoctorReport(report) {
     const lines = ['Praxis doctor', ''];

package/package.json

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