praxis-agent 0.20.14 → 0.20.18

package/dist/application/scheduled-prompt-manager.d.ts

@@ -38,6 +38,7 @@ export declare class ScheduledPromptManager {
     private readonly sessionTasks;
     private readonly dueAt;
     private readonly dueQueue;
+    private readonly pendingConfirmations;
     private readonly dynamicWakeups;
     private readonly dynamicLoopStates;
     private readonly durableIds;
@@ -54,6 +55,9 @@ export declare class ScheduledPromptManager {
     create(input: CreateScheduledPromptInput): Promise<ListedScheduledPrompt>;
     list(): Promise<ListedScheduledPrompt[]>;
     delete(id: string): Promise<boolean>;
+    pendingScheduledPrompts(): ScheduledPrompt[];
+    approveScheduledPrompt(id: string): boolean;
+    declineScheduledPrompt(id: string): boolean;
     scheduleWakeup(input: {
         delaySeconds: number;
         prompt: string;

package/dist/application/scheduled-prompt-manager.js

@@ -97,6 +97,7 @@ export class ScheduledPromptManager {
     sessionTasks = new Map();
     dueAt = new Map();
     dueQueue = [];
+    pendingConfirmations = new Map();
     dynamicWakeups = new Map();
     dynamicLoopStates = new Map();
     durableIds = new Set();
@@ -181,10 +182,29 @@ export class ScheduledPromptManager {
     async delete(id) {
         await this.initialize();
         const removed = await this.removeTask(id);
-        if (removed) {
+        const declined = this.pendingConfirmations.delete(id);
+        if (removed || declined) {
             this.dueAt.delete(id);
             this.notifyChange();
         }
+        return removed || declined;
+    }
+    pendingScheduledPrompts() {
+        return [...this.pendingConfirmations.values()];
+    }
+    approveScheduledPrompt(id) {
+        const pending = this.pendingConfirmations.get(id);
+        if (!pending)
+            return false;
+        this.pendingConfirmations.delete(id);
+        this.dueQueue.push(pending);
+        this.notifyChange();
+        return true;
+    }
+    declineScheduledPrompt(id) {
+        const removed = this.pendingConfirmations.delete(id);
+        if (removed)
+            this.notifyChange();
         return removed;
     }
     scheduleWakeup(input) {
@@ -278,6 +298,7 @@ export class ScheduledPromptManager {
         this.sessionTasks.clear();
         this.dueAt.clear();
         this.durableIds.clear();
+        this.pendingConfirmations.clear();
         this.dueQueue.length = 0;
         this.notifyChange();
     }
@@ -316,7 +337,15 @@ export class ScheduledPromptManager {
                 if (this.closed)
                     return;
                 this.durableIds.delete(task.id);
-                this.dueQueue.push({ id: task.id, prompt: task.prompt });
+                if (task.recurring) {
+                    this.dueQueue.push({ id: task.id, prompt: task.prompt });
+                }
+                else {
+                    this.pendingConfirmations.set(task.id, {
+                        id: task.id,
+                        prompt: task.prompt,
+                    });
+                }
             }
         }
     }

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

@@ -13,6 +13,7 @@ import type { ClaudeHookRunner } from '../hooks/claude-hooks.js';
 import { type TranscriptParseIssue } from '../persistence/claude-transcript-store.js';
 import type { ClaudeCostStateStore } from '../persistence/claude-cost-state-store.js';
 import { type AgentPermissionMode } from './subagent-service.js';
+import { type ScheduledPrompt } from './scheduled-prompt-manager.js';
 import { type WorkflowTaskSnapshot } from './workflow-manager.js';
 import type { WorkspaceContext } from './session-worktree.js';
 import { type ClaudeSessionCostSnapshot } from './session-cost-tracker.js';
@@ -157,6 +158,7 @@ export declare class ClaudeSessionService {
     private readonly backgroundTasks;
     private readonly worktreeManager;
     private readonly sessionCwds;
+    private readonly discoveredProjectRoots;
     private readonly sessionPermissionUpdates;
     private readonly hostedSubagents;
     private readonly hostedSubagentsByRegistry;
@@ -169,7 +171,9 @@ export declare class ClaudeSessionService {
     private closeCostSavePromise;
     private runtimeCwd;
     constructor(options: ClaudeSessionServiceOptions);
-    nextScheduledPrompt(signal?: AbortSignal): Promise<import("./scheduled-prompt-manager.js").ScheduledPrompt | null>;
+    nextScheduledPrompt(signal?: AbortSignal): Promise<ScheduledPrompt | null>;
+    private nextScheduledPromptForManager;
+    private confirmPendingScheduledPrompt;
     workflows(): readonly WorkflowTaskSnapshot[];
     mcpInspect(): Promise<readonly ClaudeMcpServerStatus[]>;
     mcpReconnect(name: string): Promise<void>;
@@ -231,6 +235,7 @@ export declare class ClaudeSessionService {
     private activeCwd;
     private restoreWorktree;
     private paths;
+    private discoverProjectRoot;
     private appendCdCommand;
     private appendAgentColorUsage;
     private appendSystemLocalCommand;

package/dist/application/session-service.js

@@ -1,10 +1,10 @@
 import { randomUUID } from 'node:crypto';
 import { appendFile, copyFile, link, lstat, mkdir, readdir, realpath, stat, unlink, } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { basename, extname, isAbsolute, join, relative } from 'node:path';
+import { basename, extname, isAbsolute, join, relative, resolve, } from 'node:path';
 import { AGENT_COLOR_DEFAULT, agentColorMessage, getClaudeEffectiveAgentColor, } from '../compatibility/claude/agent-color.js';
 import { createClaudeCompactEntries, formatClaudeCompactSummary, getCumulativeDroppedTokens, } from '../compatibility/claude/compaction.js';
-import { isClaudeSessionId, resolveClaudePaths, resolveClaudeScheduledTaskFile, } from '../compatibility/claude/paths.js';
+import { discoverClaudeProjectRoot, isClaudeSessionId, resolveClaudePaths, resolveClaudeScheduledTaskFile, } from '../compatibility/claude/paths.js';
 import { downloadClaudeFileResources, } from '../compatibility/claude/file-resources.js';
 import { createClaudeNativeFork } from '../compatibility/claude/fork.js';
 import { selectClaudeActiveTranscript, selectClaudeTranscriptAtMessage, } from '../compatibility/claude/history.js';
@@ -24,7 +24,7 @@ import { ClaudeTranscriptStore, } from '../persistence/claude-transcript-store.j
 import { InMemoryTranscriptStore } from '../persistence/in-memory-transcript-store.js';
 import { ModelCompactor } from './model-compactor.js';
 import { agentMemoryPrompt, ClaudeSubagentExecutor, StructuredOutputRegistry, } from './subagent-service.js';
-import { ScheduledPromptManager } from './scheduled-prompt-manager.js';
+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';
@@ -312,6 +312,7 @@ export class ClaudeSessionService {
     backgroundTasks;
     worktreeManager;
     sessionCwds = new Map();
+    discoveredProjectRoots = new Map();
     sessionPermissionUpdates = new Map();
     hostedSubagents = new Set();
     hostedSubagentsByRegistry = new WeakMap();
@@ -359,7 +360,53 @@ export class ClaudeSessionService {
         }
     }
     nextScheduledPrompt(signal) {
-        return this.scheduledPrompts?.next(signal) ?? Promise.resolve(null);
+        const manager = this.scheduledPrompts;
+        if (!manager)
+            return Promise.resolve(null);
+        return this.nextScheduledPromptForManager(manager, signal);
+    }
+    async nextScheduledPromptForManager(manager, signal) {
+        // Scan durable tasks so a missed one-shot surfaces as a pending
+        // confirmation instead of silently entering the normal due drain.
+        await manager.list();
+        const pending = manager.pendingScheduledPrompts()[0];
+        if (!pending)
+            return manager.next(signal);
+        const askUser = this.options.interactiveTools?.callbacks.askUser;
+        if (!askUser)
+            return manager.next(signal);
+        const approved = await this.confirmPendingScheduledPrompt(manager, pending, askUser, signal);
+        if (!approved)
+            return null;
+        // Consume the approved prompt from the scheduler due queue exactly once.
+        return manager.next(signal);
+    }
+    async confirmPendingScheduledPrompt(manager, pending, askUser, signal) {
+        const question = {
+            header: 'Missed scheduled prompt',
+            question: pending.prompt,
+            options: [
+                {
+                    label: 'Run now',
+                    description: 'Run this scheduled prompt that was missed while Praxis was not running.',
+                },
+                {
+                    label: 'Skip',
+                    description: 'Decline this scheduled prompt and discard it.',
+                },
+            ],
+            multiSelect: false,
+        };
+        const result = await askUser([question], signal);
+        const decision = result?.answers[question.question];
+        if (decision === 'Run now') {
+            return manager.approveScheduledPrompt(pending.id);
+        }
+        if (decision === 'Skip') {
+            manager.declineScheduledPrompt(pending.id);
+            return false;
+        }
+        return false;
     }
     workflows() {
         return this.workflowManager?.list() ?? [];
@@ -817,23 +864,31 @@ export class ClaudeSessionService {
         return validSessionName(metrics.text);
     }
     async sessions() {
-        const paths = this.paths(randomUUID());
+        const discoveredRoot = await discoverClaudeProjectRoot({
+            configRoot: this.options.configRoot,
+            cwd: this.activeCwd(),
+        });
+        const projectRoot = discoveredRoot ?? this.paths(randomUUID()).projectRoot;
         let names;
         try {
-            names = await readdir(paths.projectRoot);
+            names = await readdir(projectRoot);
         }
         catch (error) {
             if (error.code === 'ENOENT')
                 return [];
             throw error;
         }
-        const summaries = await Promise.all(names
+        const sessionIds = names
             .filter((name) => extname(name) === '.jsonl')
-            .map(async (name) => {
-            const sessionId = basename(name, '.jsonl');
-            if (!isClaudeSessionId(sessionId))
-                return null;
-            const sessionFile = join(paths.projectRoot, name);
+            .map((name) => basename(name, '.jsonl'))
+            .filter((sessionId) => isClaudeSessionId(sessionId));
+        if (discoveredRoot !== undefined) {
+            for (const sessionId of sessionIds) {
+                this.discoveredProjectRoots.set(sessionId, projectRoot);
+            }
+        }
+        const summaries = await Promise.all(sessionIds.map(async (sessionId) => {
+            const sessionFile = join(projectRoot, `${sessionId}.jsonl`);
             try {
                 const metadata = await lstat(sessionFile);
                 if (!metadata.isFile())
@@ -872,6 +927,7 @@ export class ClaudeSessionService {
     }
     async inspect(sessionId) {
         this.assertSessionPersistence();
+        await this.discoverProjectRoot(sessionId);
         const paths = this.paths(sessionId);
         let metadata;
         try {
@@ -912,6 +968,7 @@ export class ClaudeSessionService {
     }
     async export(sessionId) {
         this.assertSessionPersistence();
+        await this.discoverProjectRoot(sessionId);
         try {
             return await this.store(sessionId).exportReadOnly();
         }
@@ -923,6 +980,7 @@ export class ClaudeSessionService {
         }
     }
     async transcript(sessionId, resumeSessionAt) {
+        await this.discoverProjectRoot(sessionId);
         try {
             const recovery = await this.store(sessionId).loadReadOnly();
             if (recovery.entries.length === 0) {
@@ -1048,6 +1106,9 @@ export class ClaudeSessionService {
                 if (relocated.status === 'conflict') {
                     throw new Error(`Claude transcript relocation conflict: ${relocated.reason}`);
                 }
+                // The transcript moved to the exact root for the new cwd; any
+                // previously discovered alternate-hash root is now stale.
+                this.discoveredProjectRoots.delete(sessionId);
             }
             else {
                 await this.appendCdCommand(sessionId, cwd);
@@ -1664,6 +1725,9 @@ export class ClaudeSessionService {
             this.options.workspace?.setCwd(pinnedCwd);
         }
         this.runtimeCwd = pinnedCwd;
+        if (requireExisting) {
+            await this.discoverProjectRoot(sessionId);
+        }
         const sessionPaths = this.paths(sessionId);
         const toolResultDirectory = join(sessionPaths.projectRoot, sessionId, 'tool-results');
         const store = this.turnStore(sessionId);
@@ -3091,11 +3155,31 @@ export class ClaudeSessionService {
         this.worktreeManager.restore(state);
     }
     paths(sessionId) {
-        return resolveClaudePaths({
+        const exact = resolveClaudePaths({
             configDir: this.options.configRoot,
             cwd: this.sessionCwds.get(sessionId) ?? this.activeCwd(),
             sessionId,
         });
+        const discovered = this.discoveredProjectRoots.get(sessionId);
+        if (discovered === undefined)
+            return exact;
+        return {
+            ...exact,
+            projectRoot: discovered,
+            sessionFile: resolve(discovered, `${sessionId}.jsonl`),
+        };
+    }
+    async discoverProjectRoot(sessionId) {
+        if (this.discoveredProjectRoots.has(sessionId))
+            return;
+        const discovered = await discoverClaudeProjectRoot({
+            configRoot: this.options.configRoot,
+            cwd: this.sessionCwds.get(sessionId) ?? this.activeCwd(),
+            sessionId,
+        });
+        if (discovered !== undefined) {
+            this.discoveredProjectRoots.set(sessionId, discovered);
+        }
     }
     async appendCdCommand(sessionId, cwd) {
         const result = await this.store(sessionId).withLease(async (lease) => {

package/dist/cli/interactive.js

@@ -5626,7 +5626,7 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
         }
         editComposer();
     });
-    return (_jsx(TuiThemeProvider, { settings: themeSettings, children: _jsx(Box, { flexDirection: "column", children: selectingSession ? (_jsx(SessionPicker, { sessions: filteredPickerChoices, selectedIndex: selectedIndex, screenReader: axScreenReader, query: sessionSearch })) : (_jsxs(_Fragment, { children: [!axScreenReader && history.length === 0 && !sessionId ? (_jsx(WelcomePanel, { display: runtimeDisplay, width: width })) : null, sessionId ? (_jsxs(Text, { dimColor: true, children: ["Session ", sessionId.slice(0, 8)] })) : null, _jsx(Transcript, { items: history, activeText: activeText, activeThinking: activeThinking, thinkingExpanded: thinkingExpanded, detailedTranscript: thinkingExpanded || runtimeSettings.verbose, screenReader: axScreenReader }), externalEditorRequest !== null ||
+    return (_jsx(TuiThemeProvider, { settings: themeSettings, children: _jsx(Box, { flexDirection: "column", children: selectingSession ? (_jsx(SessionPicker, { sessions: filteredPickerChoices, selectedIndex: selectedIndex, screenReader: axScreenReader, query: sessionSearch })) : (_jsxs(_Fragment, { children: [!axScreenReader && history.length === 0 && !sessionId ? (_jsx(WelcomePanel, { display: runtimeDisplay, width: width, showTips: runtimeSettings.tips })) : null, sessionId ? (_jsxs(Text, { dimColor: true, children: ["Session ", sessionId.slice(0, 8)] })) : null, _jsx(Transcript, { items: history, activeText: activeText, activeThinking: activeThinking, thinkingExpanded: thinkingExpanded, detailedTranscript: thinkingExpanded || runtimeSettings.verbose, screenReader: axScreenReader }), externalEditorRequest !== null ||
                         keybindingsEditing ||
                         memoryEditorRequest !== null ? (_jsx(ExternalEditorWait, { screenReader: axScreenReader })) : permission ? (permission.kind === 'tool' && toolPermissionModel ? (_jsx(ToolPermissionDialog, { model: toolPermissionModel, selection: permissionSelection, feedbackMode: permissionFeedbackMode, feedback: input, ruleEditor: permissionRuleEditor, screenReader: axScreenReader })) : (_jsxs(DialogFrame, { title: `Retry interrupted ${permission.call.name}?`, screenReader: axScreenReader, children: [_jsx(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: _jsx(Text, { bold: true, children: describeTool(permission.call, sensitiveValues) }) }), _jsx(Text, { children: "Do you want to proceed?" }), _jsxs(Text, { inverse: !axScreenReader && permissionSelection === 0, children: [selectionPrefix(permissionSelection === 0, axScreenReader), "1. Yes"] }), _jsxs(Text, { inverse: !axScreenReader && permissionSelection === 1, children: [selectionPrefix(permissionSelection === 1, axScreenReader), "2. No"] }), permissionFeedbackMode ? (_jsxs(Text, { children: ["\u203A", ' ', input ||
                                         (permissionSelection === 0

package/dist/cli/tui/claude-style.d.ts

@@ -71,10 +71,11 @@ export interface TuiBtwEntry {
     error?: string;
 }
 export declare function useTerminalWidth(override?: number): number;
-export declare function WelcomePanel({ display, width, }: {
+export declare function WelcomePanel({ display, width, showTips, }: {
     display: TuiDisplayMetadata;
     width: number;
-}): import("react").JSX.Element;
+    showTips: boolean;
+}): import("react").JSX.Element | null;
 export declare function MarkdownText({ text }: {
     text: string;
 }): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;

package/dist/cli/tui/claude-style.js

@@ -49,17 +49,23 @@ function selectionPrefix(selected, screenReader) {
         return screenReader ? 'Selected: ' : '  ❯ ';
     return screenReader ? '' : '    ';
 }
-export function WelcomePanel({ display, width, }) {
+export function WelcomePanel({ display, width, showTips, }) {
     const palette = useTuiPalette();
+    if (!showTips)
+        return null;
     const panelWidth = Math.min(100, Math.max(32, width));
     const wide = panelWidth >= 68;
     const brand = 'Praxis';
-    // Claude 2.1.208 embeds the title in the top border row:
-    //   ╭───Claude Code v2.1.208 ───...───╮
-    // Title block = "╭" + "───" + "Praxis Code vX.Y.Z" + " " = 4 + title.length + 1 chars.
-    const title = `${brand} Code v${display.version}`;
-    const fill = Math.max(1, panelWidth - title.length - 6);
-    return (_jsxs(Box, { flexDirection: "column", width: panelWidth, children: [_jsxs(Text, { color: palette.muted, children: ['╭───', _jsx(Text, { color: palette.brand, bold: true, children: brand }), ` Code v${display.version} `, _jsx(Text, { dimColor: true, children: '─'.repeat(fill) }), '╮'] }), _jsx(Box, { borderStyle: "round", borderColor: palette.muted, borderTop: false, flexDirection: "column", width: panelWidth, paddingX: 1, children: _jsxs(Box, { flexDirection: wide ? 'row' : 'column', children: [_jsxs(Box, { alignItems: wide ? 'center' : undefined, flexDirection: "column", width: wide ? '50%' : '100%', children: [_jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "Welcome back!" }), _jsx(Text, { children: " " }), _jsx(Text, { color: palette.brand, bold: true, children: "\u2590\u259B\u2588\u2588\u2588\u259C\u258C" }), _jsx(Text, { color: palette.brand, children: "\u259D\u259C\u2588\u2588\u2588\u2588\u2588\u259B\u2598" }), _jsx(Text, { color: palette.brand, children: " \u2598\u2598 \u259D\u259D" }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [display.model ?? 'provider default', display.effort ? (_jsxs(Text, { dimColor: true, children: [" \u00B7 ", display.effort, " effort"] })) : null] }), _jsx(Text, { dimColor: true, children: compactPath(display.cwd) })] }), _jsxs(Box, { flexDirection: "column", width: wide ? '50%' : '100%', marginTop: wide ? 0 : 1, children: [_jsx(Text, { bold: true, children: "Tips for getting started" }), _jsx(Text, { children: "Run /init to create a CLAUDE.md file with instructions for Claude" }), _jsx(Text, { dimColor: true, children: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsx(Text, { bold: true, children: "What's new" }), _jsx(Text, { children: 'Subagent forking is now on by default: a `subagent_type: "fork"` subagent inherits the full conversation and prompt cache, and non-teammate agent spawns in interactive sessions now run in the background by default' }), _jsx(Text, { children: 'Type `@` in the prompt to mention another Claude session by name; Claude then uses `SendMessage` to reach that session directly' }), _jsx(Text, { children: '`SendMessage` now delivers to a bare name that exactly matches one live session, instead of asking to confirm with a ref first' }), _jsx(Text, { dimColor: true, children: "/release-notes for more" })] })] }) })] }));
+    const model = display.model ?? 'provider default';
+    const effort = display.effort ? ` · ${display.effort} effort` : '';
+    const cwd = compactPath(display.cwd);
+    // Title lives in the top border row:
+    //   ╭───Praxis Code vX.Y.Z ───...───╮
+    // Fixed prefix/suffix = "╭───"(4) + "Praxis"(6) + " Code vX.Y.Z "(8 + version)
+    // + "╮"(1), so the fill keeps the row exactly at panelWidth.
+    const fill = Math.max(1, panelWidth - display.version.length - 19);
+    const identity = `Welcome to ${brand} · ${model}${effort} · ${cwd}`;
+    return (_jsxs(Box, { flexDirection: "column", width: panelWidth, children: [_jsxs(Text, { color: palette.muted, children: ['╭───', _jsx(Text, { color: palette.brand, bold: true, children: brand }), ` Code v${display.version} `, _jsx(Text, { dimColor: true, children: '─'.repeat(fill) }), '╮'] }), wide ? (_jsxs(_Fragment, { children: [_jsx(Text, { children: identity }), _jsx(Text, { children: "/init to create CLAUDE.md \u00B7 /config to open settings" })] })) : (_jsxs(_Fragment, { children: [_jsxs(Text, { children: ["Welcome to ", brand] }), _jsxs(Text, { children: [model, effort] }), _jsx(Text, { children: cwd }), _jsx(Text, { children: "/init to create CLAUDE.md" }), _jsx(Text, { children: "/config to open settings" })] }))] }));
 }
 const INLINE_SEGMENT_CACHE_MAX = 4096;
 const inlineSegmentCache = new Map();

package/dist/cli-runtime.d.ts

@@ -7,6 +7,7 @@ import { type ModelDocument, type ModelImage, type ModelProvider, type ModelTool
 import type { InteractiveResumeOptions, InteractiveServiceFactory } from './cli/interactive.js';
 import type { TuiSlashCommand } from './cli/tui/slash-commands.js';
 import { type TuiHookConfiguration } from './cli/tui/hook-settings.js';
+import { type PraxisRuntimeSettings } from './cli/tui/runtime-settings.js';
 import { type ClaudePermissionMode } from './permissions/claude-permission-resolver.js';
 import { type ClaudeMcpServerStatus, type ClaudeMcpToolInspection } from './mcp/claude-mcp-tools.js';
 import { authenticateMcpServer } from './mcp/claude-mcp-oauth.js';
@@ -164,6 +165,14 @@ export interface CliDependencies extends InteractiveServiceFactory {
         force?: boolean;
     }) => Promise<SelfUpdateResult>;
 }
+/**
+ * Shared runtime model precedence used by every consumer (provider
+ * construction, status/doctor output, and the interactive display):
+ * explicit CLI selection > non-empty PRAXIS_MODEL > Praxis settings model,
+ * with the configured default (settings.model === 'default') falling through
+ * to the existing default behavior (undefined).
+ */
+export declare function resolveRuntimeModel(explicitModel: string | undefined, environment: NodeJS.ProcessEnv, settings: PraxisRuntimeSettings | undefined): string | undefined;
 export declare function createDefaultDependencies(entrypoint?: string): CliDependencies;
 export declare function createBackgroundWorkerRuntime(workerSink: RuntimeEventSink, dispatch: {
     argv: string[];

package/dist/cli-runtime.js

@@ -695,6 +695,20 @@ const consoleIO = {
     isTTY: Boolean(process.stdin.isTTY && process.stdout.isTTY),
     readStdinLines: () => process.stdin,
 };
+/**
+ * Shared runtime model precedence used by every consumer (provider
+ * construction, status/doctor output, and the interactive display):
+ * explicit CLI selection > non-empty PRAXIS_MODEL > Praxis settings model,
+ * with the configured default (settings.model === 'default') falling through
+ * to the existing default behavior (undefined).
+ */
+export function resolveRuntimeModel(explicitModel, environment, settings) {
+    const envModel = environment.PRAXIS_MODEL;
+    const settingsModel = settings && settings.model !== 'default' ? settings.model : undefined;
+    return (explicitModel ??
+        (envModel !== undefined && envModel.trim() !== '' ? envModel : undefined) ??
+        settingsModel);
+}
 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 };
@@ -740,7 +754,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
     let providerForMainModel;
     const context = parseContextEnvironment(runtimeEnvironment);
     const apiKey = runtimeEnvironment.PRAXIS_API_KEY;
-    const model = cli.model ?? runtimeEnvironment.PRAXIS_MODEL;
+    const model = resolveRuntimeModel(interactiveModel ?? controls.model, runtimeEnvironment, runtimeSettings);
     const providerEnvironment = apiKey && model
         ? parseProviderEnvironment(runtimeEnvironment)
         : cli.fileResources.length > 0
@@ -1300,7 +1314,9 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         ];
         const runtimeInfo = {
             cwd: workspace.cwd(),
-            model: provider?.model ?? runtimeEnvironment.PRAXIS_MODEL ?? 'unknown',
+            model: provider?.model ??
+                resolveRuntimeModel(interactiveModel ?? controls.model, runtimeEnvironment, runtimeSettings) ??
+                'unknown',
             ...(provider?.capabilities.contextWindowTokens === undefined
                 ? {}
                 : { contextWindowTokens: provider.capabilities.contextWindowTokens }),
@@ -1457,7 +1473,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                     cwd: workspace.cwd(),
                     model: service.model() ??
                         provider?.model ??
-                        runtimeEnvironment.PRAXIS_MODEL ??
+                        resolveRuntimeModel(interactiveModel ?? controls.model, runtimeEnvironment, runtimeSettings) ??
                         'unknown',
                 };
                 delete staticInfo.contextWindowTokens;
@@ -1498,7 +1514,12 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
 };
 const createDefaultAutoModeCritic = async ({ model }) => {
     const apiKey = process.env.PRAXIS_API_KEY;
-    const selectedModel = model ?? process.env.PRAXIS_MODEL;
+    const configRoot = resolve(process.env.CLAUDE_CONFIG_DIR ?? resolve(homedir(), '.claude'));
+    const runtimeSettings = await loadRuntimeSettings({
+        configRoot,
+        statePath: join(configRoot, '.claude.json'),
+    });
+    const selectedModel = resolveRuntimeModel(model, process.env, runtimeSettings);
     if (!apiKey || !selectedModel) {
         throw new Error('PRAXIS_API_KEY and a model (--model or PRAXIS_MODEL) are required');
     }
@@ -1657,6 +1678,18 @@ export function createDefaultDependencies(entrypoint = fileURLToPath(import.meta
             const { runInteractive } = await import('./cli/interactive.js');
             const interactiveControls = controls ?? DEFAULT_CLI_CONTROLS;
             const initialAdditionalDirectories = interactiveControls.addDirectories.map((directory) => realpathSync(resolve(process.cwd(), directory)));
+            const configuredRoot = process.env.CLAUDE_CONFIG_DIR || undefined;
+            const interactiveConfigRoot = resolve(configuredRoot ?? resolve(homedir(), '.claude'));
+            const interactiveStatePath = configuredRoot
+                ? join(interactiveConfigRoot, '.claude.json')
+                : resolve(homedir(), '.claude.json');
+            const interactiveRuntimeSettings = interactiveControls.safeMode || interactiveControls.bare
+                ? undefined
+                : await loadRuntimeSettings({
+                    configRoot: interactiveConfigRoot,
+                    statePath: interactiveStatePath,
+                });
+            const effectiveModel = resolveRuntimeModel(interactiveControls.model, process.env, interactiveRuntimeSettings);
             return runInteractive({
                 factory: {
                     createService: ({ additionalDirectories, cwd, ...options }) => createDefaultService({
@@ -1670,8 +1703,7 @@ export function createDefaultDependencies(entrypoint = fileURLToPath(import.meta
                         },
                         interactive: true,
                     }),
-                    scheduledPrompts: Boolean(process.env.PRAXIS_API_KEY &&
-                        (interactiveControls.model ?? process.env.PRAXIS_MODEL)),
+                    scheduledPrompts: Boolean(process.env.PRAXIS_API_KEY && effectiveModel),
                 },
                 ...(signal ? { signal } : {}),
                 ...(initialPrompt === undefined ? {} : { initialPrompt }),
@@ -1686,11 +1718,7 @@ export function createDefaultDependencies(entrypoint = fileURLToPath(import.meta
                 display: {
                     version: VERSION,
                     cwd: process.cwd(),
-                    ...(controls?.model
-                        ? { model: controls.model }
-                        : process.env.PRAXIS_MODEL
-                            ? { model: process.env.PRAXIS_MODEL }
-                            : {}),
+                    ...(effectiveModel === undefined ? {} : { model: effectiveModel }),
                     effort: controls?.effort ?? 'high',
                     permissionMode: controls?.dangerouslySkipPermissions
                         ? 'bypassPermissions'
@@ -2090,6 +2118,7 @@ async function executeDoctorCommand(args, invocation, io) {
         configRoot,
         statePath: claudeStatePath,
     });
+    const effectiveModel = resolveRuntimeModel(invocation.model, process.env, runtimeSettings);
     const report = await runDoctor({
         version: VERSION,
         executablePath: fileURLToPath(import.meta.url),
@@ -2098,7 +2127,9 @@ async function executeDoctorCommand(args, invocation, io) {
         configRoot,
         claudeStatePath,
         cwd: process.cwd(),
-        environment: process.env,
+        environment: effectiveModel === undefined
+            ? process.env
+            : { ...process.env, PRAXIS_MODEL: effectiveModel },
         autoUpdateChannel: runtimeSettings.autoUpdatesChannel,
         ...(process.argv[1] === undefined
             ? {}
@@ -4053,6 +4084,10 @@ async function execute(argv, io, dependencies, signal) {
         const startedAt = Date.now();
         const sessionId = invocation.sessionId ?? randomUUID();
         const configRoot = resolve(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude'));
+        const runtimeSettings = await loadRuntimeSettings({
+            configRoot,
+            statePath: join(configRoot, '.claude.json'),
+        });
         const text = dependencies.loadReleaseNotes
             ? await dependencies.loadReleaseNotes(configRoot)
             : await loadClaudeReleaseNotes({ configRoot });
@@ -4063,7 +4098,8 @@ async function execute(argv, io, dependencies, signal) {
         };
         const info = {
             cwd: process.cwd(),
-            model: invocation.model ?? process.env.PRAXIS_MODEL ?? 'unknown',
+            model: resolveRuntimeModel(invocation.model, process.env, runtimeSettings) ??
+                'unknown',
             tools: [],
             mcpServers: [],
             permissionMode: invocation.permissionMode,
@@ -4218,9 +4254,15 @@ async function execute(argv, io, dependencies, signal) {
                 io.stdout(transcript);
             return 0;
         }
+        const configRoot = resolve(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude'));
+        const runtimeSettings = await loadRuntimeSettings({
+            configRoot,
+            statePath: join(configRoot, '.claude.json'),
+        });
         const runtimeInfo = service.runtimeInfo?.() ?? {
             cwd: process.cwd(),
-            model: process.env.PRAXIS_MODEL ?? 'unknown',
+            model: resolveRuntimeModel(invocation.model, process.env, runtimeSettings) ??
+                'unknown',
             tools: [],
             mcpServers: [],
             permissionMode: 'default',

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

@@ -12,6 +12,21 @@ export interface ClaudePaths {
     praxisRoot: string;
 }
 export declare function sanitizeClaudeProjectPath(path: string): string;
+export interface DiscoverClaudeProjectRootOptions {
+    configRoot: string;
+    cwd: string;
+    sessionId?: string;
+}
+/**
+ * Locates the Claude project directory for a cwd, preferring the exact
+ * sanitized hash path and falling back to a long-path truncated-prefix
+ * candidate when Claude used a different runtime hash. When a sessionId is
+ * supplied, the exact directory only matches if it contains the requested
+ * regular session file; an existing exact directory without that file still
+ * falls through to the long-path prefix scan. Candidate selection is
+ * directory-prefix based and never uses mtime; ambiguous prefixes are rejected.
+ */
+export declare function discoverClaudeProjectRoot({ configRoot, cwd, sessionId, }: DiscoverClaudeProjectRootOptions): Promise<string | undefined>;
 export declare function resolveClaudeScheduledTaskFile(cwd: string): string;
 export declare function resolveClaudePaths({ cwd, sessionId, configDir, }: ResolveClaudePathsOptions): ClaudePaths;
 //# sourceMappingURL=paths.d.ts.map

package/dist/compatibility/claude/paths.js

@@ -1,5 +1,6 @@
+import { lstat, readdir } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { resolve } from 'node:path';
+import { extname, resolve } from 'node:path';
 import { getDataOwnership } from './ownership.js';
 const MAX_SANITIZED_LENGTH = 200;
 const SESSION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -21,6 +22,105 @@ export function sanitizeClaudeProjectPath(path) {
     }
     return `${sanitized.slice(0, MAX_SANITIZED_LENGTH)}-${stablePathHash(path).toString(36)}`;
 }
+async function isDirectory(path) {
+    try {
+        return (await lstat(path)).isDirectory();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+async function isRegularFile(path) {
+    try {
+        return (await lstat(path)).isFile();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+async function hasClaudeSessionTranscript(directory) {
+    let names;
+    try {
+        names = await readdir(directory);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+    for (const name of names) {
+        if (extname(name) !== '.jsonl')
+            continue;
+        if (!isClaudeSessionId(name.slice(0, -'.jsonl'.length)))
+            continue;
+        if (await isRegularFile(resolve(directory, name)))
+            return true;
+    }
+    return false;
+}
+/**
+ * Locates the Claude project directory for a cwd, preferring the exact
+ * sanitized hash path and falling back to a long-path truncated-prefix
+ * candidate when Claude used a different runtime hash. When a sessionId is
+ * supplied, the exact directory only matches if it contains the requested
+ * regular session file; an existing exact directory without that file still
+ * falls through to the long-path prefix scan. Candidate selection is
+ * directory-prefix based and never uses mtime; ambiguous prefixes are rejected.
+ */
+export async function discoverClaudeProjectRoot({ configRoot, cwd, sessionId, }) {
+    if (sessionId !== undefined && !isClaudeSessionId(sessionId)) {
+        return undefined;
+    }
+    const sanitized = sanitizeClaudeProjectPath(cwd);
+    const exactProjectRoot = resolve(configRoot, 'projects', sanitized);
+    if (sessionId !== undefined) {
+        // A sessionId targets a concrete transcript; an existing exact directory
+        // only matches when it actually holds the requested session file. Praxis
+        // may have created an empty exact directory before the transcript landed
+        // in an alternate long-path prefix directory, so fall through to the
+        // prefix scan instead of returning the empty exact directory.
+        if (await isRegularFile(resolve(exactProjectRoot, `${sessionId}.jsonl`))) {
+            return exactProjectRoot;
+        }
+    }
+    else if (await isDirectory(exactProjectRoot)) {
+        return exactProjectRoot;
+    }
+    if (sanitized.length <= MAX_SANITIZED_LENGTH)
+        return undefined;
+    const prefix = sanitized.slice(0, MAX_SANITIZED_LENGTH);
+    let names;
+    try {
+        names = await readdir(resolve(configRoot, 'projects'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    const candidates = [];
+    for (const name of names) {
+        if (!name.startsWith(`${prefix}-`))
+            continue;
+        const candidate = resolve(configRoot, 'projects', name);
+        if (!(await isDirectory(candidate)))
+            continue;
+        if (sessionId !== undefined) {
+            if (await isRegularFile(resolve(candidate, `${sessionId}.jsonl`))) {
+                candidates.push(candidate);
+            }
+            continue;
+        }
+        if (await hasClaudeSessionTranscript(candidate)) {
+            candidates.push(candidate);
+        }
+    }
+    return candidates.length === 1 ? candidates[0] : undefined;
+}
 export function resolveClaudeScheduledTaskFile(cwd) {
     const policy = getDataOwnership('scheduled-prompts');
     if (policy.plane !== 'shared' ||

package/package.json

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