praxis-agent 0.32.0 → 0.33.0

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,6 +193,8 @@ 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 hostedSubagentsByRegistry;
@@ -194,6 +206,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;
@@ -246,8 +261,12 @@ export declare class ClaudeSessionService {
     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>;
@@ -303,7 +322,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;

package/dist/application/session-service.js

@@ -1,7 +1,7 @@
 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, resolve, } from 'node:path';
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, } from 'node:path';
 import { isPathWithin } from '../platform/path-containment.js';
 import { AGENT_COLOR_DEFAULT, agentColorMessage, getClaudeEffectiveAgentColor, } from '../compatibility/claude/agent-color.js';
 import { createClaudeCompactEntries, formatClaudeCompactSummary, getCumulativeDroppedTokens, } from '../compatibility/claude/compaction.js';
@@ -9,11 +9,12 @@ import { discoverClaudeProjectRoot, isClaudeSessionId, resolveClaudePaths, resol
 import { resolveDataPlanePaths, resolveScheduledTaskFile, } from '../persistence/data-plane.js';
 import { downloadClaudeFileResources, } from '../compatibility/claude/file-resources.js';
 import { createClaudeNativeFork } from '../compatibility/claude/fork.js';
-import { selectClaudeActiveTranscript, selectClaudeTranscriptAtMessage, } from '../compatibility/claude/history.js';
+import { selectClaudeActiveTranscript, selectClaudeTranscriptAtMessage, selectClaudeTranscriptFromNewestLeaf, } from '../compatibility/claude/history.js';
 import { ClaudeFileHistory } from '../compatibility/claude/file-history.js';
-import { getClaudePrLink } from '../compatibility/claude/pr-links.js';
-import { getClaudeAgentSetting, getClaudeLastPrompt, projectClaudeDisplayTranscript, projectClaudeModelMessages, } from '../compatibility/claude/projection.js';
+import { getClaudeAgentSetting, projectClaudeDisplayTranscript, projectClaudeModelMessages, } from '../compatibility/claude/projection.js';
 import { selectClaudeSchemaAdapter, } from '../compatibility/claude/schema.js';
+import { createClaudeDurableMetadataSnapshot, createClaudeTagEntry, mergeClaudeDurableMetadataSnapshot, reduceClaudeSessionMetadata, } from '../compatibility/claude/session-metadata.js';
+import { classifyClaudeInterruption, } from '../compatibility/claude/interruption.js';
 import { findUnresolvedClaudeToolCalls, getClaudeContentBlocks, } from '../compatibility/claude/tool-links.js';
 import { createClaudeAgentSettingEntry, createClaudeHookAttachmentEntries, createClaudeLastPromptEntry, createClaudeRuleAttachmentEntry, translateProviderEvents, } from '../compatibility/claude/translation.js';
 import { AgentRunCancelledError, AgentRuntime, ModelProviderError, } from '../core/runtime.js';
@@ -25,6 +26,7 @@ import { injectFirstUserMessageContext, } from '../core/context.js';
 import { ClaudeHookToolCoordinator } from '../hooks/claude-hook-tools.js';
 import { ClaudeFileChangeWatcher } from '../hooks/claude-file-change-watcher.js';
 import { ClaudeTranscriptStore, } from '../persistence/claude-transcript-store.js';
+import { ClaudeSessionIndexCandidateError, readClaudeSessionIndexes, } from '../persistence/claude-session-index.js';
 import { InMemoryTranscriptStore } from '../persistence/in-memory-transcript-store.js';
 import { ModelCompactor } from './model-compactor.js';
 import { agentMemoryPrompt, ClaudeSubagentExecutor, StructuredOutputRegistry, } from './subagent-service.js';
@@ -630,6 +632,8 @@ export class ClaudeSessionService {
     worktreeManager;
     sessionCwds = new Map();
     discoveredProjectRoots = new Map();
+    explicitSessionFiles = new Map();
+    explicitResumeLeafUuids = new Map();
     sessionPermissionUpdates = new Map();
     hostedSubagents = new Set();
     hostedSubagentsByRegistry = new WeakMap();
@@ -641,6 +645,9 @@ export class ClaudeSessionService {
     sessionCostTrackers = new Map();
     activeCostSessionId;
     closeCostSavePromise;
+    closeMetadataSavePromise;
+    durableMetadataSessions = new Set();
+    durableMetadataSnapshots = new Map();
     sessionMemoryControllers = new Map();
     resolvedSessionMemoryProvider;
     hookLifecycle;
@@ -815,6 +822,8 @@ export class ClaudeSessionService {
         await Promise.all([...this.sessionMemoryControllers.values()].map((controller) => controller.close()));
         this.sessionMemoryControllers.clear();
         await this.workflowManager?.close();
+        this.closeMetadataSavePromise ??= Promise.all([...this.durableMetadataSessions].map((sessionId) => this.reappendDurableMetadata(sessionId))).then(() => undefined);
+        await this.closeMetadataSavePromise;
         this.closeCostSavePromise ??= this.persistActiveSessionCost();
         await this.closeCostSavePromise;
         this.mcpClosePromise ??= this.options.mcp?.close?.() ?? Promise.resolve();
@@ -1364,10 +1373,12 @@ export class ClaudeSessionService {
         return validSessionName(metrics.text);
     }
     async sessions() {
-        const discoveredRoot = await discoverClaudeProjectRoot({
-            configRoot: this.options.configRoot,
-            cwd: this.activeCwd(),
-        });
+        const discoveredRoot = this.options.dataPlane === 'native'
+            ? undefined
+            : await discoverClaudeProjectRoot({
+                configRoot: this.options.configRoot,
+                cwd: this.activeCwd(),
+            });
         const projectRoot = discoveredRoot ?? this.paths(randomUUID()).projectRoot;
         let names;
         try {
@@ -1378,33 +1389,55 @@ export class ClaudeSessionService {
                 return [];
             throw error;
         }
-        const sessionIds = names
+        const discoveredSessionIds = names
             .filter((name) => extname(name) === '.jsonl')
             .map((name) => basename(name, '.jsonl'))
             .filter((sessionId) => isClaudeSessionId(sessionId));
+        const sessionIds = [
+            ...new Set([
+                ...discoveredSessionIds,
+                ...this.explicitSessionFiles.keys(),
+            ]),
+        ];
         if (discoveredRoot !== undefined) {
-            for (const sessionId of sessionIds) {
+            for (const sessionId of discoveredSessionIds) {
                 this.discoveredProjectRoots.set(sessionId, projectRoot);
             }
         }
-        const summaries = await Promise.all(sessionIds.map(async (sessionId) => {
-            const sessionFile = join(projectRoot, `${sessionId}.jsonl`);
+        const indexResults = await readClaudeSessionIndexes(sessionIds.map((sessionId) => ({
+            sessionId,
+            path: this.explicitSessionFiles.get(sessionId) ??
+                join(projectRoot, `${sessionId}.jsonl`),
+        })), this.schema);
+        const summaries = indexResults.map((result) => {
             try {
-                const metadata = await lstat(sessionFile);
-                if (!metadata.isFile())
-                    return null;
-                const recovery = await this.store(sessionId).loadReadOnly();
-                if (!(await lstat(sessionFile)).isFile())
-                    return null;
-                const name = this.sessionName(recovery.entries);
-                const prLink = getClaudePrLink(recovery.entries, sessionId);
+                if ('error' in result)
+                    throw result.error;
+                const { sessionId, index } = result;
+                const metadata = reduceClaudeSessionMetadata(index.entries, sessionId);
+                const name = metadata.title ?? metadata.agentName;
+                const prLink = metadata.prLink;
                 return {
                     sessionId,
-                    ...(name === null ? {} : { name }),
-                    lastPrompt: getClaudeLastPrompt(recovery.entries),
-                    updatedAt: metadata.mtime.toISOString(),
-                    status: this.sessionStatus(recovery.issue, recovery.entries.length),
-                    issue: recovery.issue,
+                    ...(name === undefined ? {} : { name }),
+                    ...(metadata.tag === undefined ? {} : { tag: metadata.tag }),
+                    ...(metadata.agentName === undefined
+                        ? {}
+                        : { agentName: metadata.agentName }),
+                    ...(metadata.agentColor === undefined
+                        ? {}
+                        : { agentColor: metadata.agentColor }),
+                    ...(metadata.agentSetting === undefined
+                        ? {}
+                        : { agentSetting: metadata.agentSetting }),
+                    ...(metadata.permissionMode === undefined
+                        ? {}
+                        : { permissionMode: metadata.permissionMode }),
+                    ...(metadata.mode === undefined ? {} : { mode: metadata.mode }),
+                    lastPrompt: metadata.lastPrompt ?? null,
+                    updatedAt: index.updatedAt,
+                    status: this.sessionStatus(index.issue, index.entries.length),
+                    issue: index.issue,
                     ...(prLink
                         ? {
                             prNumber: prLink.prNumber,
@@ -1415,15 +1448,18 @@ export class ClaudeSessionService {
                 };
             }
             catch (error) {
-                if (typeof error.code === 'string') {
+                if (error instanceof ClaudeSessionIndexCandidateError)
+                    return null;
+                if (['ENOENT', 'ENOTDIR', 'ELOOP'].includes(error.code ?? '')) {
                     return null;
                 }
                 throw error;
             }
-        }));
+        });
         return summaries
             .filter((summary) => summary !== null)
-            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt) ||
+            left.sessionId.localeCompare(right.sessionId));
     }
     async inspect(sessionId) {
         this.assertSessionPersistence();
@@ -1440,10 +1476,32 @@ export class ClaudeSessionService {
             throw error;
         }
         const recovery = await this.store(sessionId).loadReadOnly();
-        const prLink = getClaudePrLink(recovery.entries, sessionId);
+        const sessionMetadata = reduceClaudeSessionMetadata(recovery.entries, sessionId);
+        const prLink = sessionMetadata.prLink;
         return {
             sessionId,
-            lastPrompt: getClaudeLastPrompt(recovery.entries),
+            ...(sessionMetadata.title === undefined
+                ? {}
+                : { name: sessionMetadata.title }),
+            ...(sessionMetadata.tag === undefined
+                ? {}
+                : { tag: sessionMetadata.tag }),
+            ...(sessionMetadata.agentName === undefined
+                ? {}
+                : { agentName: sessionMetadata.agentName }),
+            ...(sessionMetadata.agentColor === undefined
+                ? {}
+                : { agentColor: sessionMetadata.agentColor }),
+            ...(sessionMetadata.agentSetting === undefined
+                ? {}
+                : { agentSetting: sessionMetadata.agentSetting }),
+            ...(sessionMetadata.permissionMode === undefined
+                ? {}
+                : { permissionMode: sessionMetadata.permissionMode }),
+            ...(sessionMetadata.mode === undefined
+                ? {}
+                : { mode: sessionMetadata.mode }),
+            lastPrompt: sessionMetadata.lastPrompt ?? null,
             updatedAt: metadata.mtime.toISOString(),
             status: this.sessionStatus(recovery.issue, recovery.entries.length),
             issue: recovery.issue,
@@ -1479,6 +1537,84 @@ export class ClaudeSessionService {
             throw error;
         }
     }
+    async registerResumePath(requestedPath) {
+        this.assertSessionPersistence();
+        const path = resolve(requestedPath);
+        const pathMetadata = await lstat(path);
+        if (!pathMetadata.isFile()) {
+            throw new Error(`Claude resume path must be a regular JSONL file: ${path}`);
+        }
+        if (extname(path).toLowerCase() !== '.jsonl') {
+            throw new Error(`Claude resume path must end in .jsonl: ${path}`);
+        }
+        const sessionId = basename(path, '.jsonl');
+        if (!isClaudeSessionId(sessionId)) {
+            throw new Error(`Claude resume path filename must be a session UUID: ${path}`);
+        }
+        const canonicalPath = await realpath(path);
+        const exact = this.pathsForCwd(sessionId, this.activeCwd());
+        const candidate = new ClaudeTranscriptStore({
+            sessionFile: canonicalPath,
+            lockFile: join(exact.praxisRoot, 'locks', `${sessionId}.lock`),
+            schema: this.schema,
+        });
+        const snapshot = await candidate.load();
+        if (!snapshot.tail.newlineTerminated) {
+            throw new Error('Claude resume transcript must be newline-terminated');
+        }
+        if (snapshot.entries.length === 0) {
+            throw new Error('Claude resume transcript must not be empty');
+        }
+        let matchingSessionIdentity = false;
+        for (const entry of snapshot.entries) {
+            if (entry.sessionId === sessionId)
+                matchingSessionIdentity = true;
+            if (typeof entry.sessionId === 'string' &&
+                entry.sessionId !== sessionId) {
+                throw new Error(`Claude resume transcript contains a different sessionId: ${String(entry.sessionId)}`);
+            }
+        }
+        if (!matchingSessionIdentity) {
+            throw new Error('Claude resume transcript is missing its sessionId');
+        }
+        const selected = selectClaudeTranscriptFromNewestLeaf(snapshot.entries);
+        this.explicitSessionFiles.set(sessionId, canonicalPath);
+        this.explicitResumeLeafUuids.set(sessionId, selected.leafUuid);
+        this.discoveredProjectRoots.set(sessionId, dirname(canonicalPath));
+        const metadata = reduceClaudeSessionMetadata(snapshot.entries, sessionId);
+        const prLink = metadata.prLink;
+        return {
+            sessionId,
+            ...(metadata.title === undefined ? {} : { name: metadata.title }),
+            ...(metadata.tag === undefined ? {} : { tag: metadata.tag }),
+            ...(metadata.agentName === undefined
+                ? {}
+                : { agentName: metadata.agentName }),
+            ...(metadata.agentColor === undefined
+                ? {}
+                : { agentColor: metadata.agentColor }),
+            ...(metadata.agentSetting === undefined
+                ? {}
+                : { agentSetting: metadata.agentSetting }),
+            ...(metadata.permissionMode === undefined
+                ? {}
+                : { permissionMode: metadata.permissionMode }),
+            ...(metadata.mode === undefined ? {} : { mode: metadata.mode }),
+            lastPrompt: metadata.lastPrompt ?? null,
+            updatedAt: pathMetadata.mtime.toISOString(),
+            status: this.sessionStatus(null, snapshot.entries.length),
+            issue: null,
+            ...(prLink === undefined
+                ? {}
+                : {
+                    prNumber: prLink.prNumber,
+                    ...(prLink.prUrl === undefined ? {} : { prUrl: prLink.prUrl }),
+                    ...(prLink.prRepository === undefined
+                        ? {}
+                        : { prRepository: prLink.prRepository }),
+                }),
+        };
+    }
     async transcript(sessionId, resumeSessionAt) {
         await this.discoverProjectRoot(sessionId);
         try {
@@ -1498,6 +1634,24 @@ export class ClaudeSessionService {
             throw error;
         }
     }
+    async interruption(sessionId) {
+        this.assertSessionPersistence();
+        await this.discoverProjectRoot(sessionId);
+        const snapshot = await this.store(sessionId).loadReadOnly();
+        if (snapshot.entries.length === 0) {
+            throw new Error(`Claude session not found: ${sessionId}`);
+        }
+        return classifyClaudeInterruption(snapshot.entries);
+    }
+    async metadata(sessionId) {
+        this.assertSessionPersistence();
+        await this.discoverProjectRoot(sessionId);
+        const snapshot = await this.store(sessionId).loadReadOnly();
+        if (snapshot.entries.length === 0) {
+            throw new Error(`Claude session not found: ${sessionId}`);
+        }
+        return reduceClaudeSessionMetadata(snapshot.entries, sessionId);
+    }
     async rename(sessionId, name) {
         this.assertWritable();
         const normalized = name.trim();
@@ -1508,16 +1662,44 @@ export class ClaudeSessionService {
             if (snapshot.entries.length === 0) {
                 throw new Error(`Claude session not found: ${sessionId}`);
             }
+            this.rememberDurableMetadata(sessionId, snapshot.entries);
             if (this.hasSessionName(snapshot.entries, normalized))
                 return;
-            const appendResult = await lease.appendMany(snapshot.tail, this.sessionNameEntries(sessionId, normalized));
+            const entries = this.sessionNameEntries(sessionId, normalized);
+            const appendResult = await lease.appendMany(snapshot.tail, entries);
             if (appendResult.status === 'conflict') {
                 throw new Error(`Claude transcript rename conflict: ${appendResult.reason}`);
             }
+            this.rememberDurableMetadata(sessionId, [...snapshot.entries, ...entries]);
         });
         if (result.status === 'conflict') {
             throw new Error(`Claude transcript rename conflict: ${result.reason}`);
         }
+        this.durableMetadataSessions.add(sessionId);
+    }
+    async tag(sessionId, tag) {
+        this.assertWritable();
+        const normalized = tag.trim();
+        const entry = createClaudeTagEntry(sessionId, normalized);
+        const result = await this.turnStore(sessionId).withLease(async (lease) => {
+            const snapshot = await lease.load();
+            if (snapshot.entries.length === 0) {
+                throw new Error(`Claude session not found: ${sessionId}`);
+            }
+            this.rememberDurableMetadata(sessionId, snapshot.entries);
+            const current = reduceClaudeSessionMetadata(snapshot.entries, sessionId);
+            if (current.tag === normalized)
+                return;
+            const appendResult = await lease.append(snapshot.tail, entry);
+            if (appendResult.status === 'conflict') {
+                throw new Error(`Claude transcript tag conflict: ${appendResult.reason}`);
+            }
+            this.rememberDurableMetadata(sessionId, [...snapshot.entries, entry]);
+        });
+        if (result.status === 'conflict') {
+            throw new Error(`Claude transcript tag conflict: ${result.reason}`);
+        }
+        this.durableMetadataSessions.add(sessionId);
     }
     async changeCwd(sessionId, requestedCwd) {
         this.assertWritable();
@@ -1976,6 +2158,18 @@ export class ClaudeSessionService {
             if (appendResult.status === 'conflict') {
                 throw new Error(`Claude transcript append conflict: ${appendResult.reason}`);
             }
+            const metadataEntries = createClaudeDurableMetadataSnapshot([...snapshot.entries, ...entries], sessionId);
+            if (metadataEntries.length > 0) {
+                const metadataAppend = await lease.appendMany(appendResult.tail, metadataEntries);
+                if (metadataAppend.status === 'conflict') {
+                    throw new Error(`Claude metadata snapshot conflict: ${metadataAppend.reason}`);
+                }
+            }
+            this.rememberDurableMetadata(sessionId, [
+                ...snapshot.entries,
+                ...entries,
+                ...metadataEntries,
+            ]);
             this.options.projectMemoryRecall?.recordCompact(sessionId);
             this.options.eventSink?.({
                 type: 'compact-boundary',
@@ -2256,6 +2450,9 @@ export class ClaudeSessionService {
             throw new Error('Shell command must not be empty');
         }
         await this.activateSessionCostTracker(sessionId);
+        if (this.options.sessionPersistence !== false) {
+            this.durableMetadataSessions.add(sessionId);
+        }
         await this.ensureFileResources(sessionId, signal);
         this.worktreeManager?.bindSession(sessionId);
         if (this.options.initialWorktree) {
@@ -2283,6 +2480,7 @@ export class ClaudeSessionService {
                 }
             }
             let snapshot = await lease.load();
+            let automaticReplayPrompt;
             if (requireExisting &&
                 this.options.sessionPersistence === false &&
                 snapshot.entries.length === 0) {
@@ -2296,12 +2494,43 @@ export class ClaudeSessionService {
             if (requireExisting && snapshot.entries.length === 0) {
                 throw new Error(`Claude session not found: ${sessionId}`);
             }
+            this.rememberDurableMetadata(sessionId, snapshot.entries);
             if (resumeSessionAt !== undefined) {
                 snapshot = {
                     entries: selectClaudeTranscriptAtMessage(snapshot.entries, resumeSessionAt),
                     tail: { ...snapshot.tail, branchParentUuid: resumeSessionAt },
                 };
             }
+            else if (this.explicitResumeLeafUuids.has(sessionId)) {
+                const selected = selectClaudeTranscriptFromNewestLeaf(snapshot.entries);
+                this.explicitResumeLeafUuids.set(sessionId, selected.leafUuid);
+                snapshot = {
+                    entries: selected.entries,
+                    tail: { ...snapshot.tail, branchParentUuid: selected.leafUuid },
+                };
+            }
+            if (requireExisting &&
+                resumeSessionAt === undefined &&
+                this.options.resumeInterruptedTurn === true &&
+                shellCommand === undefined &&
+                !skipUserPrompt &&
+                !(this.options.approveRecovery !== undefined &&
+                    findUnresolvedClaudeToolCalls(snapshot.entries).length > 0)) {
+                const interruption = classifyClaudeInterruption(snapshot.entries);
+                if ((interruption.kind === 'interrupted-prompt' ||
+                    interruption.kind === 'interrupted-turn') &&
+                    interruption.prompt !== undefined &&
+                    interruption.replayEntries !== undefined) {
+                    automaticReplayPrompt = interruption.prompt;
+                    snapshot = {
+                        entries: interruption.replayEntries,
+                        tail: {
+                            ...snapshot.tail,
+                            branchParentUuid: interruption.replayParentUuid ?? null,
+                        },
+                    };
+                }
+            }
             const initialTransition = this.worktreeManager?.consumeTransition('__initial__');
             if (initialTransition && snapshot.entries.length === 0) {
                 const stateEntry = {
@@ -2314,6 +2543,7 @@ export class ClaudeSessionService {
                     entries: [...snapshot.entries, stateEntry],
                     tail: stateTail,
                 };
+                this.rememberDurableMetadata(sessionId, snapshot.entries);
             }
             this.restoreWorktree(snapshot.entries);
             this.options.interactiveTools?.restore(sessionId, snapshot.entries);
@@ -2329,18 +2559,20 @@ export class ClaudeSessionService {
                     entries: [...snapshot.entries, ...entries],
                     tail: appendResult.tail,
                 };
+                this.rememberDurableMetadata(sessionId, snapshot.entries);
             }
             const agentName = this.options.agent ?? getClaudeAgentSetting(snapshot.entries);
             const agent = this.resolveAgent(agentName);
             const provider = this.providerForAgent(agent);
             this.activeProvider = provider;
-            const effectivePrompt = !requireExisting &&
-                !skipUserPrompt &&
-                !this.options.agentInitialPromptHandledExternally &&
-                shellCommand === undefined &&
-                agent?.initialPrompt
-                ? `${agent.initialPrompt}\n\n${prompt}`
-                : prompt;
+            const effectivePrompt = automaticReplayPrompt ??
+                (!requireExisting &&
+                    !skipUserPrompt &&
+                    !this.options.agentInitialPromptHandledExternally &&
+                    shellCommand === undefined &&
+                    agent?.initialPrompt
+                    ? `${agent.initialPrompt}\n\n${prompt}`
+                    : prompt);
             const projectMemoryRecallTurn = !skipUserPrompt && shellCommand === undefined
                 ? this.options.projectMemoryRecall?.prefetch({
                     sessionId,
@@ -3302,6 +3534,18 @@ export class ClaudeSessionService {
                         entries: [...snapshot.entries, ...entries],
                         tail: appendResult.tail,
                     };
+                    const metadataEntries = createClaudeDurableMetadataSnapshot(snapshot.entries, sessionId);
+                    if (metadataEntries.length > 0) {
+                        const metadataAppend = await lease.appendMany(snapshot.tail, metadataEntries);
+                        if (metadataAppend.status === 'conflict') {
+                            throw new Error(`Claude metadata snapshot conflict: ${metadataAppend.reason}`);
+                        }
+                        snapshot = {
+                            entries: [...snapshot.entries, ...metadataEntries],
+                            tail: metadataAppend.tail,
+                        };
+                    }
+                    this.rememberDurableMetadata(sessionId, snapshot.entries);
                     await this.runAdvisoryHook(sessionId, 'PostCompact', { trigger: 'auto', compact_summary: compacted.summary }, 'auto', signal);
                     // The boundary is durable: mirror Claude's full-compact behavior by
                     // rerunning SessionStart with source compact and refreshing the
@@ -3720,12 +3964,18 @@ export class ClaudeSessionService {
                     throw new Error('Could not locate final assistant response');
                 }
                 if (!skipUserPrompt) {
-                    await this.append(lease, snapshot.tail, createClaudeLastPromptEntry({
+                    const lastPrompt = createClaudeLastPromptEntry({
                         sessionId,
                         lastPrompt: effectivePrompt,
                         leafUuid: finalLeafUuid,
-                    }));
+                    });
+                    const tail = await this.append(lease, snapshot.tail, lastPrompt);
+                    snapshot = {
+                        entries: [...snapshot.entries, lastPrompt],
+                        tail,
+                    };
                 }
+                this.rememberDurableMetadata(sessionId, snapshot.entries);
                 const totalUsage = mergeUsage(mergeUsage(mergeUsage(recoveryUsage, compactionUsage), shellUsage), result.usage);
                 const tracker = this.sessionCostTrackers.get(sessionId);
                 if (!tracker) {
@@ -4104,6 +4354,14 @@ export class ClaudeSessionService {
     }
     paths(sessionId) {
         const exact = this.pathsForCwd(sessionId, this.sessionCwds.get(sessionId) ?? this.activeCwd());
+        const explicitSessionFile = this.explicitSessionFiles.get(sessionId);
+        if (explicitSessionFile !== undefined) {
+            return {
+                ...exact,
+                projectRoot: dirname(explicitSessionFile),
+                sessionFile: explicitSessionFile,
+            };
+        }
         if (this.options.dataPlane === 'native')
             return exact;
         const discovered = this.discoveredProjectRoots.get(sessionId);
@@ -4509,6 +4767,41 @@ export class ClaudeSessionService {
             schema: this.schema,
         });
     }
+    /**
+     * 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.
+     */
+    async reappendDurableMetadata(sessionId) {
+        if (this.options.sessionPersistence === false)
+            return;
+        await this.discoverProjectRoot(sessionId);
+        let result;
+        try {
+            result = await this.store(sessionId).withLease(async (lease) => {
+                const snapshot = await lease.loadIndex?.();
+                if (snapshot === undefined)
+                    return;
+                if (snapshot.entries.length === 0)
+                    return;
+                const entries = mergeClaudeDurableMetadataSnapshot(this.durableMetadataSnapshots.get(sessionId) ?? [], snapshot.tailEntries, sessionId);
+                if (entries.length === 0)
+                    return;
+                const appended = await lease.appendMetadataSnapshot(snapshot.tail, entries);
+                if (appended.status === 'conflict') {
+                    throw new Error(`Claude metadata snapshot conflict: ${appended.reason}`);
+                }
+            });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+        if (result.status === 'conflict') {
+            throw new Error(`Claude metadata snapshot conflict: ${result.reason}`);
+        }
+    }
     turnStore(sessionId) {
         if (this.options.sessionPersistence !== false)
             return this.store(sessionId);
@@ -4519,6 +4812,12 @@ export class ClaudeSessionService {
         }
         return store;
     }
+    rememberDurableMetadata(sessionId, observed) {
+        const snapshot = mergeClaudeDurableMetadataSnapshot(this.durableMetadataSnapshots.get(sessionId) ?? [], observed, sessionId);
+        if (snapshot.length > 0) {
+            this.durableMetadataSnapshots.set(sessionId, snapshot);
+        }
+    }
     assertSessionPersistence() {
         if (this.options.sessionPersistence === false) {
             throw new Error('Session persistence is disabled');
@@ -4773,7 +5072,9 @@ export class ClaudeSessionService {
         return result.tail;
     }
     logicalTailUuid(tail) {
-        return tail.branchParentUuid ?? tail.lastUuid;
+        return 'branchParentUuid' in tail
+            ? (tail.branchParentUuid ?? null)
+            : tail.lastUuid;
     }
 }
 //# sourceMappingURL=session-service.js.map