praxis-agent 0.20.16 → 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/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.16",
+  "version": "0.20.18",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",