praxis-agent 0.32.0 → 0.34.0

package/dist/application/managed-worktree.js

@@ -1,6 +1,6 @@
 import { execFile } from 'node:child_process';
-import { lstat, mkdir } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
+import { lstat, mkdir, realpath } from 'node:fs/promises';
+import { isAbsolute, join, resolve } from 'node:path';
 import { promisify } from 'node:util';
 const execFileAsync = promisify(execFile);
 async function git(cwd, args) {
@@ -124,4 +124,56 @@ export async function createManagedWorktree(options) {
         },
     };
 }
+/** Reattaches only to a real, registered Git worktree. Persisted metadata is
+ * untrusted input, so an arbitrary directory can never become an execution
+ * cwd merely because it exists. Restored worktrees are retained for audit. */
+export async function restoreManagedWorktree(options) {
+    if (!isAbsolute(options.path) || options.path.includes('\0')) {
+        throw new Error(`Invalid retained ${options.label.toLowerCase()} worktree path`);
+    }
+    const path = resolve(options.path);
+    let entry;
+    try {
+        entry = await lstat(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`Retained ${options.label.toLowerCase()} worktree is missing: ${path}`);
+        }
+        throw error;
+    }
+    if (entry.isSymbolicLink() || !entry.isDirectory()) {
+        throw new Error(`Retained ${options.label.toLowerCase()} worktree must be a real directory: ${path}`);
+    }
+    let root;
+    let registered;
+    let canonicalPath;
+    try {
+        ;
+        [root, canonicalPath] = await Promise.all([
+            git(options.cwd, ['rev-parse', '--show-toplevel']),
+            realpath(path),
+        ]);
+        registered = await registeredWorktrees(root);
+    }
+    catch (error) {
+        throw new Error(`Could not inspect retained ${options.label.toLowerCase()} worktree ${path}: ${error.message}`);
+    }
+    if (!registered.has(path) && !registered.has(canonicalPath)) {
+        throw new Error(`Retained ${options.label.toLowerCase()} worktree is not registered: ${path}`);
+    }
+    const worktreeRoot = await realpath(resolve(await git(path, ['rev-parse', '--show-toplevel'])));
+    if (worktreeRoot !== canonicalPath) {
+        throw new Error(`Retained ${options.label.toLowerCase()} worktree path is not its root: ${path}`);
+    }
+    return {
+        cwd: path,
+        async cleanup() {
+            return {
+                retained: true,
+                reason: `${options.label} worktree was restored and retained at ${path}`,
+            };
+        },
+    };
+}
 //# sourceMappingURL=managed-worktree.js.map

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

@@ -4,6 +4,8 @@ import { type DataPlane } from '../persistence/data-plane.js';
 import { type ClaudeFileResource, type ClaudeFileResourceConfig } from '../compatibility/claude/file-resources.js';
 import { type ClaudeDisplayTranscriptItem } from '../compatibility/claude/projection.js';
 import { type ClaudeTranscriptEntry } from '../compatibility/claude/schema.js';
+import { type ClaudeSessionMetadata } from '../compatibility/claude/session-metadata.js';
+import { type ClaudeInterruptionClassification } from '../compatibility/claude/interruption.js';
 import { type ModelDocument, type ModelImage, type ModelToolCall, type ModelProvider, type ModelUsage, type PermissionApproval, type PermissionDecision, type PermissionResolver, type PermissionUpdate, type RuntimeEventSink, type ToolRegistry } from '../core/runtime.js';
 import { type BackgroundTaskSnapshot } from './background-task-runtime.js';
 import type { ModelPricingRegistry } from '../core/usage.js';
@@ -38,6 +40,8 @@ export interface ClaudeSessionServiceOptions {
     persistPermissionUpdates?: (updates: readonly PermissionUpdate[]) => void | Promise<void>;
     approveTool?: (call: ModelToolCall, originalCall?: ModelToolCall, decision?: PermissionDecision) => PermissionApproval | Promise<PermissionApproval>;
     approveRecovery?: (call: ModelToolCall) => boolean | Promise<boolean>;
+    /** Explicit Claude-compatible opt-in for replaying an interrupted turn. */
+    resumeInterruptedTurn?: boolean;
     contextAssembler?: ContextAssembler;
     conditionalRuleResolver?: Pick<ClaudeConditionalRuleResolver, 'resolve'>;
     extensions?: ClaudeExtensionCatalog;
@@ -125,6 +129,12 @@ export interface SideQuestionForkResult {
 export interface SessionSummary {
     sessionId: string;
     name?: string;
+    tag?: string;
+    agentName?: string;
+    agentColor?: string;
+    agentSetting?: string;
+    permissionMode?: string;
+    mode?: string;
     lastPrompt: string | null;
     updatedAt: string;
     status: SessionStatus;
@@ -183,10 +193,18 @@ export declare class ClaudeSessionService {
     private readonly worktreeManager;
     private readonly sessionCwds;
     private readonly discoveredProjectRoots;
+    private readonly explicitSessionFiles;
+    private readonly explicitResumeLeafUuids;
     private readonly sessionPermissionUpdates;
     private readonly hostedSubagents;
+    private readonly subagentExecutors;
     private readonly hostedSubagentsByRegistry;
+    private readonly subagentExecutorSessions;
+    private readonly hostedSubagentNotificationPumps;
+    private readonly hostedSubagentPumpPromises;
+    private readonly hostedSubagentNotificationReservations;
     private readonly backgroundNotificationWrites;
+    private closing;
     private readonly downloadedFileResourceSessions;
     private readonly detachedHookRuns;
     private activeProvider;
@@ -194,6 +212,9 @@ export declare class ClaudeSessionService {
     private readonly sessionCostTrackers;
     private activeCostSessionId;
     private closeCostSavePromise;
+    private closeMetadataSavePromise;
+    private readonly durableMetadataSessions;
+    private readonly durableMetadataSnapshots;
     private readonly sessionMemoryControllers;
     private resolvedSessionMemoryProvider;
     private readonly hookLifecycle;
@@ -212,6 +233,10 @@ export declare class ClaudeSessionService {
     private requireMcp;
     taskSnapshots(sessionId: string): Promise<BackgroundTaskSnapshot>;
     stopTask(sessionId: string, taskId: string): Promise<void>;
+    backgroundForegroundTask(sessionId: string): import("./background-agent-manager.js").BackgroundAgentSnapshot;
+    private sendOwnedBackgroundAgent;
+    private sessionSubagentExecutors;
+    private collectSubagentNotifications;
     private applyPermissionUpdates;
     close(): Promise<void>;
     transitionHookSession(sessionId: string, reason: Exclude<HookSessionEndReason, 'other'>): Promise<void>;
@@ -240,14 +265,19 @@ export declare class ClaudeSessionService {
     resumeShell(sessionId: string, command: string, signal?: AbortSignal, name?: string, resumeSessionAt?: string): Promise<SessionRunResult>;
     answerSideQuestion(sessionId: string | undefined, question: string, signal?: AbortSignal, onDelta?: (delta: string) => void, permissionMode?: ClaudePermissionMode): Promise<SideQuestionResult>;
     forkSideQuestion(sessionId: string, question: string, signal?: AbortSignal): Promise<SideQuestionForkResult>;
+    private startHostedSubagentNotificationPump;
     promptSuggestion(sessionId: string, signal?: AbortSignal): Promise<string | null>;
     sessionNameSuggestion(sessionId: string, signal?: AbortSignal): Promise<string | null>;
     sessions(): Promise<SessionSummary[]>;
     inspect(sessionId: string): Promise<SessionInspection>;
     readEffectiveAgentColor(sessionId: string): Promise<AgentColorName | undefined>;
     export(sessionId: string): Promise<Buffer>;
+    registerResumePath(requestedPath: string): Promise<SessionSummary>;
     transcript(sessionId: string, resumeSessionAt?: string): Promise<ClaudeDisplayTranscriptItem[]>;
+    interruption(sessionId: string): Promise<ClaudeInterruptionClassification>;
+    metadata(sessionId: string): Promise<ClaudeSessionMetadata>;
     rename(sessionId: string, name: string): Promise<void>;
+    tag(sessionId: string, tag: string): Promise<void>;
     changeCwd(sessionId: string | undefined, requestedCwd: string): Promise<string>;
     recordCdUsage(sessionId: string): Promise<void>;
     approveRecentlyDenied(sessionId: string, display: string): Promise<void>;
@@ -269,6 +299,7 @@ export declare class ClaudeSessionService {
     private persistActiveSessionCost;
     private recordAuxiliaryMetrics;
     costSnapshot(sessionId: string): Promise<ClaudeSessionCostSnapshot>;
+    private withDetachedSubagentUsage;
     private executeTurn;
     private ensureFileResources;
     private translationContext;
@@ -303,7 +334,14 @@ export declare class ClaudeSessionService {
     private cdCommandEntries;
     private localCommandEntries;
     private store;
+    /**
+     * Refreshes metadata under the transcript lease before writing a compact
+     * tail snapshot. This prevents a long-lived process from overwriting a
+     * newer title or tag appended by another writer.
+     */
+    private reappendDurableMetadata;
     private turnStore;
+    private rememberDurableMetadata;
     private assertSessionPersistence;
     private assertWritable;
     private sessionStatus;