praxis-agent 0.7.0 → 0.8.0

package/dist/cli.js

@@ -15,14 +15,15 @@ import { loadClaudeContextResources, loadClaudeSettings, loadClaudeSharedResourc
 import { AgentRunCancelledError, } from './core/runtime.js';
 import { projectTuiHooks, } from './cli/tui/hook-settings.js';
 import { DEFAULT_CLI_CONTROLS, resolveCliControls } from './cli/controls.js';
+import { applyRuntimeSettingDefaults, loadRuntimeSettings, runtimeSettingsSystemPrompt, } from './cli/tui/runtime-settings.js';
 import { createCliDebugSink } from './cli/debug.js';
 import { ClaudePermissionResolver, } from './permissions/claude-permission-resolver.js';
 import { createClaudeModelAutoClassifier, defaultClaudeAutoModeConfig, loadClaudeAutoModeConfig, } from './permissions/claude-auto-classifier.js';
 import { ClaudeExtensionPermissionResolver, ClaudeExtensionToolRegistry, } from './extensions/claude-extension-tools.js';
 import { ClaudeExtensionCatalog } from './extensions/claude-extensions.js';
 import { ClaudeHookRunner } from './hooks/claude-hooks.js';
-import { ClaudeMcpToolRegistry } from './mcp/claude-mcp-tools.js';
-import { ClaudeMcpManagement, mcpScope, } from './mcp/claude-mcp-management.js';
+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 { detectInstalledClaudeVersion } from './platform/claude-version.js';
@@ -76,7 +77,7 @@ function fileResourceHeaders(environment, providerEnvironment, credential) {
             : {}),
     };
 }
-function createProviderForModel(apiKey, providerEnvironment, context, controls) {
+function createProviderForModel(apiKey, providerEnvironment, context, controls, explicitThinkingControls) {
     return (selectedModel) => {
         const providerOptions = {
             apiKey,
@@ -107,8 +108,8 @@ function createProviderForModel(apiKey, providerEnvironment, context, controls)
             })
             : new OpenAICompatibleProvider({
                 ...providerOptions,
-                ...(controls.thinking === undefined &&
-                    controls.maxThinkingTokens === undefined
+                ...(explicitThinkingControls.thinking === undefined &&
+                    explicitThinkingControls.maxThinkingTokens === undefined
                     ? {}
                     : {
                         thinking: {
@@ -686,7 +687,7 @@ const consoleIO = {
     isTTY: Boolean(process.stdin.isTTY && process.stdout.isTTY),
     readStdinLines: () => process.stdin,
 };
-const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = false, approveRecovery, approveTool, agent, model: interactiveModel, effort: interactiveEffort, permissionMode: interactivePermissionMode, controls = DEFAULT_CLI_CONTROLS, interactive = false, sessionKind, signal, exposeToolRegistry = false, onElicitation, askUser, approvePlan, emitToolUseSummaries = false, cwd: requestedCwd, configRoot: requestedConfigRoot, environment, providerEnvironment: requestedProviderEnvironment, }) => {
+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, configRoot: requestedConfigRoot, environment, providerEnvironment: requestedProviderEnvironment, }) => {
     const runtimeEnvironment = requestedProviderEnvironment ?? process.env;
     const claudeVersion = await detectInstalledClaudeVersion();
     const cwd = requestedCwd ?? process.cwd();
@@ -696,14 +697,24 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
     const claudeStatePath = requestedConfigRoot || configuredRoot
         ? join(configRoot, '.claude.json')
         : resolve(homedir(), '.claude.json');
+    const runtimeSettings = controls.safeMode || controls.bare
+        ? undefined
+        : await loadRuntimeSettings({ configRoot, statePath: claudeStatePath });
+    const runtimeSettingsPrompt = runtimeSettingsSystemPrompt(runtimeSettings);
     const cli = await resolveCliControls({
-        ...controls,
+        ...applyRuntimeSettingDefaults(controls, runtimeSettings),
         ...(interactiveModel === undefined ? {} : { model: interactiveModel }),
         ...(interactiveEffort === undefined ? {} : { effort: interactiveEffort }),
         ...(interactivePermissionMode === undefined
             ? {}
             : { permissionMode: interactivePermissionMode }),
     }, cwd);
+    const effectiveAppendSystemPrompt = [
+        runtimeSettingsPrompt,
+        cli.appendSystemPrompt,
+    ]
+        .filter((value) => value !== undefined)
+        .join('\n');
     const debug = cli.debug !== undefined || cli.debugFile !== undefined
         ? createCliDebugSink(eventSink, {
             cwd,
@@ -738,7 +749,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         if (!providerEnvironment) {
             throw new Error('Provider environment is unavailable');
         }
-        providerForModel = createProviderForModel(apiKey, providerEnvironment, context, cli);
+        providerForModel = createProviderForModel(apiKey, providerEnvironment, context, cli, controls);
         const models = [model, ...(cli.fallbackModels ?? [])].filter((candidate, index, all) => all.indexOf(candidate) === index);
         const createProvider = providerForModel;
         const providers = models.map((candidate) => createProvider(candidate));
@@ -932,6 +943,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         allowedTools: cli.allowedTools,
         disallowedTools: cli.disallowedTools,
         permissionMode,
+        ...(isSessionActionApproved ? { isSessionActionApproved } : {}),
         ...(permissionMode === 'auto'
             ? {
                 autoClassifier: createClaudeModelAutoClassifier(hostedToolProvider),
@@ -958,6 +970,13 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         additionalReadDirectories: [claudeBackgroundTaskParent(cwd)],
         ...(environment ? { environment } : {}),
     });
+    const runtimeMcpResources = async (candidates) => {
+        const management = new ClaudeMcpManagement({
+            configRoot,
+            cwd: workspace.cwd(),
+        });
+        return filterDisabledMcpResources(candidates, await management.disabled());
+    };
     const mcpTools = await ClaudeMcpToolRegistry.connect({
         base: cli.bare
             ? localTools
@@ -965,11 +984,47 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                 base: localTools,
                 provider: hostedToolProvider,
             }),
-        resources: resources.mcp,
+        resources: await runtimeMcpResources(resources.mcp),
+        reloadResources: async () => {
+            if (cli.strictMcpConfig)
+                return runtimeMcpResources(cli.mcpResources);
+            const refreshed = await loadClaudeSharedResources({
+                configRoot,
+                cwd: workspace.cwd(),
+                claudeStatePath,
+                ...(automaticSettingSources === undefined
+                    ? {}
+                    : { settingSources: automaticSettingSources }),
+            });
+            return runtimeMcpResources([
+                ...refreshed.mcp,
+                ...pluginResources.mcp,
+                ...cli.mcpResources,
+            ]);
+        },
         cwd,
         configRoot,
         onWarning: (message) => runtimeEventSink({ type: 'warning', message }),
         onPromptsChanged: (prompts) => extensions.setMcpPrompts(prompts),
+        authenticateServer: async (name) => {
+            const record = await new ClaudeMcpManagement({
+                configRoot,
+                cwd: workspace.cwd(),
+            }).get(name);
+            const server = mcpOAuthServerIdentity(record.name, record.config);
+            const oauth = mcpOauthOptions(record.config);
+            const clientSecret = oauth.clientId
+                ? await new ClaudeMcpOAuthStore({ configRoot }).readClientSecret(server)
+                : undefined;
+            await authenticateMcpServer({
+                configRoot,
+                server,
+                ...oauth,
+                ...(clientSecret ? { clientSecret } : {}),
+                noBrowser: false,
+                write: (message) => process.stdout.write(message),
+            });
+        },
         ...(onElicitation ? { onElicitation } : {}),
         eventSink: runtimeEventSink,
         ...(signal ? { signal } : {}),
@@ -1036,7 +1091,8 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                 cli.tools.includes('default') ||
                 cli.tools.includes(name)) &&
             !cli.disallowedTools.includes(name));
-        const selectedWorkflowTools = workflowToolNames.filter((name) => cli.sessionPersistence &&
+        const selectedWorkflowTools = workflowToolNames.filter((name) => (runtimeSettings?.workflows ?? true) &&
+            cli.sessionPersistence &&
             !cli.bare &&
             (cli.tools === undefined ||
                 cli.tools.includes('default') ||
@@ -1098,6 +1154,9 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                 enabledTools: selectedInteractiveTools,
                 callbacks: { askUser, approvePlan },
                 permissionResolverForMode,
+                settings: {
+                    useAutoModeDuringPlan: runtimeSettings?.useAutoModeDuringPlan ?? true,
+                },
             })
             : undefined;
         const service = new ClaudeSessionService({
@@ -1105,6 +1164,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             provider: hostedToolProvider,
             ...(providerForModel ? { providerForModel } : {}),
             tools: filteredTools,
+            mcp: mcpTools,
             permissions,
             permissionResolverForMode,
             extensions,
@@ -1117,6 +1177,9 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             emitToolUseSummaries,
             enableWorktrees: cli.worktreeRequested || selectedWorktreeTools.length > 0,
             worktreeToolNames: selectedWorktreeTools,
+            ...(runtimeSettings
+                ? { worktreeBaseRef: runtimeSettings.worktreeBaseRef }
+                : {}),
             ...(interactiveTools ? { interactiveTools } : {}),
             ...(hooks ? { hooks } : {}),
             ...(agent ? { agent } : {}),
@@ -1130,9 +1193,9 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                 ...(cli.systemPrompt === undefined
                     ? {}
                     : { systemPrompt: cli.systemPrompt }),
-                ...(cli.appendSystemPrompt === undefined
-                    ? {}
-                    : { appendSystemPrompt: cli.appendSystemPrompt }),
+                ...(effectiveAppendSystemPrompt
+                    ? { appendSystemPrompt: effectiveAppendSystemPrompt }
+                    : {}),
             }),
             conditionalRuleResolver: new ClaudeConditionalRuleResolver({
                 loadResources: loadContextResources,
@@ -1142,7 +1205,9 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                 : {}),
             ...(permissionApprover ? { approveTool: permissionApprover } : {}),
             ...(approveRecovery ? { approveRecovery } : {}),
-            fileCheckpointing: runtimeEnvironment.CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING === 'true',
+            fileCheckpointing: runtimeEnvironment.CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING ===
+                'true' || runtimeSettings?.checkpoints === true,
+            autoCompact: runtimeSettings?.autoCompact ?? true,
             fileRewindRoots: [
                 ...cli.additionalDirectories,
                 ...(memoryDirectory ? [memoryDirectory] : []),
@@ -1213,6 +1278,8 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             rewindPoints: (sessionId) => service.rewindPoints(sessionId),
             changeCwd: (sessionId, cwd) => service.changeCwd(sessionId, cwd),
             recordCdUsage: (sessionId) => service.recordCdUsage(sessionId),
+            approveRecentlyDenied: (sessionId, display) => service.approveRecentlyDenied(sessionId, display),
+            retryRecentlyDenied: (sessionId, display, retrySignal) => service.retryRecentlyDenied(sessionId, display, retrySignal),
             answerSideQuestion: (sessionId, question, sideSignal, onDelta, permissionMode) => service.answerSideQuestion(sessionId, question, sideSignal, onDelta, permissionMode),
             recordBtwUsage: (sessionId, permissionMode) => service.recordBtwUsage(sessionId, permissionMode),
             recordBackgroundUsage: (sessionId, permissionMode) => service.recordBackgroundUsage(sessionId, permissionMode),
@@ -1257,6 +1324,13 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                 source: definition.kind,
             })),
             hookConfiguration: async () => projectTuiHooks(settings),
+            mcpInspect: () => service.mcpInspect(),
+            mcpReconnect: (name) => service.mcpReconnect(name),
+            mcpAuthenticate: (name) => service.mcpAuthenticate(name),
+            mcpReload: () => service.mcpReload(),
+            mcpTools: (name) => service.mcpTools(name),
+            taskSnapshots: (sessionId) => service.taskSnapshots(sessionId),
+            stopTask: (sessionId, taskId) => service.stopTask(sessionId, taskId),
             agentDefinitions: () => extensions.agentDefinitions(),
             inspect: (sessionId) => service.inspect(sessionId),
             export: (sessionId) => service.export(sessionId),
@@ -1322,7 +1396,7 @@ const createDefaultAutoModeCritic = async ({ model }) => {
     if (!apiKey || !selectedModel) {
         throw new Error('PRAXIS_API_KEY and a model (--model or PRAXIS_MODEL) are required');
     }
-    return createProviderForModel(apiKey, parseProviderEnvironment(process.env), parseContextEnvironment(process.env), {})(selectedModel);
+    return createProviderForModel(apiKey, parseProviderEnvironment(process.env), parseContextEnvironment(process.env), {}, {})(selectedModel);
 };
 const defaultPluginEvalRuntimeFactory = {
     create: async (options) => {
@@ -1413,7 +1487,7 @@ const defaultPluginEvalJudge = {
         const apiKey = environment.PRAXIS_API_KEY;
         if (!apiKey)
             throw new Error('PRAXIS_API_KEY is required for paid eval graders');
-        const provider = createProviderForModel(apiKey, parseProviderEnvironment(environment), parseContextEnvironment(environment), {})(model);
+        const provider = createProviderForModel(apiKey, parseProviderEnvironment(environment), parseContextEnvironment(environment), {}, {})(model);
         const prompt = `You are an eval judge. Return only JSON matching {"passed":boolean,"explanation":string}.
 
 Criteria:
@@ -1928,7 +2002,13 @@ async function executeSelfUpdateCommand(argv, io, dependencies) {
         if (operands.length > 0) {
             throw new Error(`${command} takes no operands`);
         }
-        const result = await dependencies.selfUpdate?.({ operation: 'update' });
+        const runtimeSettings = await loadRuntimeSettings();
+        const result = await dependencies.selfUpdate?.({
+            operation: 'update',
+            ...(runtimeSettings.autoUpdatesChannel === 'latest'
+                ? {}
+                : { target: runtimeSettings.autoUpdatesChannel }),
+        });
         if (!result)
             throw new Error('Self-update unavailable');
         if (json)

package/dist/compatibility/claude/schema.js

@@ -38,12 +38,14 @@ const FORKABLE_SYSTEM_SUBTYPES = new Set([
     'away_summary',
     'compact_boundary',
     'local_command',
+    'permission_retry',
     'stop_hook_summary',
     'turn_duration',
 ]);
 const APPENDABLE_SYSTEM_SUBTYPES = new Set([
     'compact_boundary',
     'local_command',
+    'permission_retry',
 ]);
 const FORKABLE_ATTACHMENT_TYPES = new Set([
     'agent_listing_delta',

package/dist/core/runtime.d.ts

@@ -167,6 +167,9 @@ export type RuntimeEvent = {
     type: 'permission-decision';
     callId: string;
     behavior: PermissionBehavior;
+    reason?: string;
+    source?: 'auto-classifier' | 'rule' | 'mode' | 'default';
+    autoModeOutcome?: AutoModePermissionOutcome;
 } | {
     type: 'tool-result';
     callId: string;
@@ -310,18 +313,27 @@ export interface PermissionResolutionContext {
     messages?: readonly ModelMessage[];
     signal?: AbortSignal;
 }
+export type PermissionDecisionSource = 'auto-classifier' | 'rule' | 'mode' | 'default';
+export type AutoModePermissionOutcome = 'blocked' | 'unavailable';
 export type PermissionDecision = {
     behavior: 'allow';
+    source?: PermissionDecisionSource;
 } | {
     behavior: 'ask';
     reason?: string;
+    source?: PermissionDecisionSource;
 } | {
     behavior: 'deny';
     reason: string;
+    source?: PermissionDecisionSource;
 };
 export interface PermissionResolver {
     resolve(call: ModelToolCall, context?: PermissionResolutionContext): PermissionDecision | Promise<PermissionDecision>;
 }
+export declare function annotatePermissionDecision<T extends PermissionDecision>(decision: T, source: PermissionDecisionSource): T;
+export declare function permissionDecisionSource(decision: PermissionDecision): PermissionDecisionSource | undefined;
+export declare function annotateAutoModePermissionOutcome<T extends PermissionDecision>(decision: T, outcome: AutoModePermissionOutcome): T;
+export declare function autoModePermissionOutcome(decision: PermissionDecision): AutoModePermissionOutcome | undefined;
 export interface AgentRunObserver {
     assistantCompleted(message: {
         content: string;

package/dist/core/runtime.js

@@ -1,3 +1,20 @@
+const permissionDecisionSources = new WeakMap();
+const autoModePermissionOutcomes = new WeakMap();
+export function annotatePermissionDecision(decision, source) {
+    if (decision.source === undefined)
+        permissionDecisionSources.set(decision, source);
+    return decision;
+}
+export function permissionDecisionSource(decision) {
+    return decision.source ?? permissionDecisionSources.get(decision);
+}
+export function annotateAutoModePermissionOutcome(decision, outcome) {
+    autoModePermissionOutcomes.set(decision, outcome);
+    return decision;
+}
+export function autoModePermissionOutcome(decision) {
+    return autoModePermissionOutcomes.get(decision);
+}
 export class ModelProviderError extends Error {
     name = 'ModelProviderError';
     retryable;
@@ -446,10 +463,17 @@ export class AgentRuntime {
         }
         await this.requireRecoveryApproval(prepared, request);
         const decision = await permissions.resolve(prepared, context);
+        const source = permissionDecisionSource(decision);
+        const autoModeOutcome = autoModePermissionOutcome(decision);
         this.emit({
             type: 'permission-decision',
             callId: call.id,
             behavior: decision.behavior,
+            ...('reason' in decision && decision.reason !== undefined
+                ? { reason: decision.reason }
+                : {}),
+            ...(source === undefined ? {} : { source }),
+            ...(autoModeOutcome === undefined ? {} : { autoModeOutcome }),
         });
         let allowed = decision.behavior === 'allow';
         let denialReason;

package/dist/maintenance/self-update.js

@@ -41,7 +41,7 @@ export async function runSelfUpdate(options) {
     }
     const operation = options.operation;
     const force = options.force === true;
-    const target = operation === 'install' ? requireTarget(options.target) : 'latest';
+    const target = requireTarget(options.target ?? (operation === 'install' ? 'stable' : 'latest'));
     const npmExecutable = options.npmExecutable ?? (process.platform === 'win32' ? 'npm.cmd' : 'npm');
     const spec = `${packageName}@${target}`;
     const args = [

package/dist/mcp/claude-mcp-management.d.ts

@@ -1,4 +1,4 @@
-import { type ClaudeResourceScope } from '../compatibility/claude/shared-resources.js';
+import { type ClaudeJsonResource, type ClaudeResourceScope } from '../compatibility/claude/shared-resources.js';
 export type McpScope = ClaudeResourceScope;
 export type McpServerConfig = Record<string, unknown>;
 export interface McpServerRecord {
@@ -10,16 +10,21 @@ export interface McpServerRecord {
 interface McpManagementOptions {
     configRoot?: string;
     cwd: string;
+    beforeCommit?: (path: string, attempt: number) => Promise<void>;
 }
+export declare function filterDisabledMcpResources(resources: readonly ClaudeJsonResource[], disabledNames: readonly string[]): readonly ClaudeJsonResource[];
 export declare class ClaudeMcpManagement {
     private readonly configRoot;
     private readonly cwd;
+    private readonly beforeCommit?;
     constructor(options: McpManagementOptions);
     list(scope?: McpScope): Promise<McpServerRecord[]>;
     get(name: string, scope?: McpScope): Promise<McpServerRecord>;
     add(name: string, config: McpServerConfig, scope?: McpScope): Promise<McpServerRecord>;
     remove(name: string, scope?: McpScope): Promise<McpServerRecord>;
     resetProjectChoices(): Promise<void>;
+    disabled(): Promise<readonly string[]>;
+    setEnabled(name: string, scope: McpScope, enabled: boolean): Promise<void>;
     private target;
     private validateName;
 }