yepanywhere 0.5.2 → 0.6.0

package/dist/routes/sessions.js

@@ -1,4 +1,5 @@
-import { PROMPT_SUGGESTION_MODES, HELPER_SIDE_MODEL_CHEAPEST, HELPER_SIDE_MODEL_SAME_AS_MAIN, RECAP_MODES, getModelContextWindow, isUrlProjectId, thinkingOptionToConfig, truncateSessionTitle, } from "../../bundled/@yep-anywhere/shared/dist/index.js";
+import { ALL_PERMISSION_MODES, PROMPT_SUGGESTION_MODES, buildEffectiveAgentContext, clampRecapAfterSeconds, getModelContextWindow, isUrlProjectId, isWorkstreamId, mainWorkstreamId, thinkingOptionToConfig, truncateSessionTitle, } from "../../bundled/@yep-anywhere/shared/dist/index.js";
+import { randomUUID } from "node:crypto";
 import { mkdir } from "node:fs/promises";
 import { performance } from "node:perf_hooks";
 import { Hono } from "hono";
@@ -6,21 +7,36 @@ import { augmentTextBlocks } from "../augments/markdown-augments.js";
 import { getLogger } from "../logging/logger.js";
 import { DETACHED_PROJECT_PATH, encodeProjectId } from "../projects/paths.js";
 import { ensureRemoteDirectory } from "../sdk/remote-spawn.js";
+import { parseSlashCommandSubmission } from "../sdk/slashCommandEmulation.js";
 import { getProjectDirFromCwd, syncSessions } from "../sdk/session-sync.js";
 import { appendApprovalAuditLog } from "../security/approvalAuditLog.js";
 import { CodexSessionReader } from "../sessions/codex-reader.js";
 import { cloneClaudeSession, cloneCodexSession } from "../sessions/fork.js";
-import { GeminiSessionReader } from "../sessions/gemini-reader.js";
-import { buildDag } from "../sessions/dag.js";
 import { GrokSessionReader } from "../sessions/grok-reader.js";
+import { extractLastAgentExcerpt } from "../sessions/agent-excerpt.js";
 import { normalizeSession } from "../sessions/normalization.js";
+import { applyRecapOverlayToSession, applyRecapOverlayToSummary, hasEquivalentRecapMessage, hasUnreadProviderContent, latestRecapMessage, mergeRecapMessages, } from "../sessions/recap-overlays.js";
 import { sliceAfterMessageIdWithMatch, sliceAtCompactBoundaries, sliceAtUserTurnBoundary, } from "../sessions/pagination.js";
+import { augmentTaskListSnapshots, pruneTaskListSnapshotsToLatest, } from "../augments/task-list-augments.js";
 import { augmentEditToolUses, augmentPersistedSessionMessages, } from "../sessions/persisted-augments.js";
-import { findSessionSummaryAcrossProviders } from "../sessions/provider-resolution.js";
-import { isValidSshHostAlias, normalizeSshHostAlias, } from "../utils/sshHostAlias.js";
+import { findSessionSummaryAcrossProviders, getSessionSources, } from "../sessions/provider-resolution.js";
+import { getProvider } from "../sdk/providers/index.js";
+import { getStaticSlashCommandsForProvider } from "../sdk/providers/staticSlashCommands.js";
+import { ResumeCompactionError } from "../supervisor/Supervisor.js";
+import { buildUserMessageMetadata, normalizeOptionalServiceTier, parseHelperSettings, parseOptionalExecutor, parseOptionalResumeMode, } from "./session-request-helpers.js";
+import { resolveCompactPercent, resolveCompactWindow, } from "./session-compact-thresholds.js";
+import { getClaudeResumeBlockerFromReader, } from "./session-claude-resume-guard.js";
 const SESSION_DETAIL_SLOW_LOG_MS = 250;
-const CLAUDE_RESUME_API_ERROR_RECOVERY = "handoff-required";
-const CLAUDE_RESUME_API_ERROR_MESSAGE = "Claude session cannot be safely resumed because the Claude SDK recorded an API-error response as the latest assistant message. Start a handoff session instead.";
+const DEFAULT_SESSION_DETAIL_TAIL_COMPACTIONS = 2;
+const LARGE_FULL_HISTORY_MESSAGE_THRESHOLD = 1000;
+async function getSessionSlashCommands(process, provider) {
+    if (process?.supportsDynamicCommands) {
+        const commands = await process.supportedCommands();
+        if (commands)
+            return commands;
+    }
+    return getStaticSlashCommandsForProvider(provider);
+}
 function roundedMs(value) {
     return Math.round(value * 10) / 10;
 }
@@ -39,242 +55,116 @@ function isQueuedResponse(result) {
 function isQueueFullResponse(result) {
     return "error" in result && result.error === "queue_full";
 }
-function getClaudeResumeApiErrorBlocker(messages) {
-    const { activeBranch } = buildDag(messages);
-    for (let i = activeBranch.length - 1; i >= 0; i--) {
-        const raw = activeBranch[i]?.raw;
-        if (raw?.type !== "assistant") {
-            continue;
-        }
-        if (raw.isApiErrorMessage !== true) {
-            return null;
-        }
-        const apiError = raw;
-        return {
-            error: CLAUDE_RESUME_API_ERROR_MESSAGE,
-            recovery: CLAUDE_RESUME_API_ERROR_RECOVERY,
-            messageId: raw.message.id,
-            apiErrorStatus: apiError.apiErrorStatus,
-        };
-    }
-    return null;
-}
-async function getClaudeResumeBlockerFromReader(reader, sessionId, projectId) {
-    const session = await reader.getSession(sessionId, projectId);
-    if (!session) {
-        return null;
-    }
-    if (session.data.provider !== "claude" &&
-        session.data.provider !== "claude-ollama") {
-        return null;
-    }
-    return getClaudeResumeApiErrorBlocker(session.data.session.messages);
-}
-function parseOptionalExecutor(rawExecutor) {
-    if (rawExecutor === undefined || rawExecutor === null) {
-        return { executor: undefined };
-    }
-    if (typeof rawExecutor !== "string") {
-        return { executor: undefined, error: "executor must be a string" };
-    }
-    const executor = normalizeSshHostAlias(rawExecutor);
-    if (!executor) {
-        return { executor: undefined };
-    }
-    if (!isValidSshHostAlias(executor)) {
-        return {
-            executor: undefined,
-            error: "executor must be a valid SSH host alias",
-        };
-    }
-    return { executor };
-}
-function normalizeOptionalServiceTier(rawServiceTier) {
-    if (typeof rawServiceTier !== "string") {
-        return undefined;
-    }
-    const serviceTier = rawServiceTier.trim();
-    return /^[A-Za-z0-9_-]{1,64}$/.test(serviceTier)
-        ? serviceTier
-        : undefined;
-}
-function parseOptionalRecapMode(rawMode) {
-    if (rawMode === undefined || rawMode === null || rawMode === "") {
-        return { recapMode: undefined };
-    }
-    if (typeof rawMode !== "string" ||
-        !RECAP_MODES.includes(rawMode)) {
-        return {
-            recapMode: undefined,
-            error: "recapMode must be one of: off, native, side-session",
-        };
-    }
-    return { recapMode: rawMode };
-}
-function parseOptionalPromptSuggestionMode(rawMode) {
-    if (rawMode === undefined || rawMode === null || rawMode === "") {
-        return { promptSuggestionMode: undefined };
-    }
-    if (typeof rawMode !== "string" ||
-        !PROMPT_SUGGESTION_MODES.includes(rawMode)) {
-        return {
-            promptSuggestionMode: undefined,
-            error: "promptSuggestionMode must be one of: off, native",
-        };
-    }
-    return { promptSuggestionMode: rawMode };
-}
-function parseOptionalHelperSideModel(rawModel) {
-    if (rawModel === undefined || rawModel === null || rawModel === "") {
-        return { helperSideModel: undefined };
-    }
-    if (typeof rawModel !== "string") {
-        return { helperSideModel: undefined, error: "helperSideModel must be a string" };
-    }
-    const trimmed = rawModel.trim();
-    if (!trimmed) {
-        return { helperSideModel: undefined };
-    }
-    return {
-        helperSideModel: trimmed === HELPER_SIDE_MODEL_SAME_AS_MAIN
-            ? HELPER_SIDE_MODEL_SAME_AS_MAIN
-            : trimmed === HELPER_SIDE_MODEL_CHEAPEST
-                ? HELPER_SIDE_MODEL_CHEAPEST
-                : trimmed.slice(0, 200),
-    };
-}
-function parseHelperSettings(body) {
-    const recap = parseOptionalRecapMode(body.recapMode);
-    if (recap.error) {
-        return {
-            recapMode: undefined,
-            promptSuggestionMode: undefined,
-            helperSideModel: undefined,
-            error: recap.error,
-        };
-    }
-    const promptSuggestion = parseOptionalPromptSuggestionMode(body.promptSuggestionMode);
-    if (promptSuggestion.error) {
-        return {
-            recapMode: undefined,
-            promptSuggestionMode: undefined,
-            helperSideModel: undefined,
-            error: promptSuggestion.error,
-        };
-    }
-    const helperModel = parseOptionalHelperSideModel(body.helperSideModel);
-    if (helperModel.error) {
-        return {
-            recapMode: undefined,
-            promptSuggestionMode: undefined,
-            helperSideModel: undefined,
-            error: helperModel.error,
-        };
-    }
-    return {
-        recapMode: recap.recapMode,
-        promptSuggestionMode: promptSuggestion.promptSuggestionMode,
-        helperSideModel: helperModel.helperSideModel,
-    };
-}
 function isCodexProviderName(provider) {
     return provider === "codex" || provider === "codex-oss";
 }
-function parseDeferredPlacement(body) {
-    const beforeTempId = typeof body.insertBeforeTempId === "string" &&
-        body.insertBeforeTempId.trim()
-        ? body.insertBeforeTempId.trim()
-        : undefined;
-    const afterTempId = typeof body.insertAfterTempId === "string" && body.insertAfterTempId.trim()
-        ? body.insertAfterTempId.trim()
-        : undefined;
-    const replaceTempId = typeof body.replaceDeferredTempId === "string" &&
-        body.replaceDeferredTempId.trim()
-        ? body.replaceDeferredTempId.trim()
-        : undefined;
-    if (!beforeTempId && !afterTempId && !replaceTempId) {
-        return undefined;
-    }
-    return {
-        ...(afterTempId ? { afterTempId } : {}),
-        ...(beforeTempId ? { beforeTempId } : {}),
-        ...(replaceTempId ? { replaceTempId } : {}),
-    };
-}
-const USER_MESSAGE_DELIVERY_INTENTS = new Set(["direct", "steer", "deferred", "patient"]);
 const AUTO_COMPACT_CONTEXT_PERCENT_THRESHOLD = 85;
 const AUTO_COMPACT_MODEL_PREFIXES = ["gpt-5.3-codex-spark"];
 const AUTO_COMPACT_TARGET_PROVIDERS = new Set([
     "codex",
     "codex-oss",
 ]);
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+function providerResolutionDeps(deps) {
+    return {
+        readerFactory: deps.readerFactory,
+        sessionIndexService: deps.sessionIndexService,
+        codexSessionsDir: deps.codexSessionsDir,
+        codexReaderFactory: deps.codexReaderFactory,
+        geminiSessionsDir: deps.geminiSessionsDir,
+        geminiReaderFactory: deps.geminiReaderFactory,
+        geminiHashToCwd: deps.geminiScanner?.getHashToCwd(),
+        grokSessionsDir: deps.grokSessionsDir,
+        grokReaderFactory: deps.grokReaderFactory,
+        piSessionsDir: deps.piSessionsDir,
+        piReaderFactory: deps.piReaderFactory,
+    };
 }
-function parseIsoTimestamp(value) {
-    if (typeof value !== "string" || !value.trim())
-        return undefined;
-    return Number.isNaN(Date.parse(value)) ? undefined : value;
+function persistedPatientQueueSummary(item) {
+    const attachmentCount = (item.message.attachments?.length ?? 0) +
+        (item.message.images?.length ?? 0) +
+        (item.message.documents?.length ?? 0);
+    const tempId = item.message.tempId ?? item.source?.tempId;
+    return {
+        id: item.id,
+        ...(tempId ? { tempId } : {}),
+        content: item.message.text,
+        timestamp: item.queuedAt,
+        ...(item.message.attachments?.length
+            ? { attachments: item.message.attachments }
+            : {}),
+        ...(attachmentCount > 0 ? { attachmentCount } : {}),
+        ...(item.message.metadata ? { metadata: item.message.metadata } : {}),
+        kind: "patient",
+        status: item.status === "paused-after-restart" ? item.status : "queued",
+        sessionId: item.sessionId,
+        projectId: item.projectId,
+        queuedAt: item.queuedAt,
+        createdAt: item.createdAt,
+        updatedAt: item.updatedAt,
+    };
 }
-function parseDeliveryIntent(value) {
-    return typeof value === "string" &&
-        USER_MESSAGE_DELIVERY_INTENTS.has(value)
-        ? value
-        : undefined;
+function isApprovalAuditLogEnabled(deps) {
+    return (deps.serverSettingsService?.getSetting("approvalAuditLogEnabled") === true);
 }
-function parseShortString(value, maxLength) {
-    if (typeof value !== "string")
-        return undefined;
-    const trimmed = value.trim();
-    return trimmed ? trimmed.slice(0, maxLength) : undefined;
+function recoveredPatientQueueSummaries(deps, sessionId) {
+    return recoveredPatientQueueItems(deps, sessionId).map(persistedPatientQueueSummary);
 }
-function parseStringList(value, maxItems, maxLength) {
-    if (!Array.isArray(value))
-        return undefined;
-    const parsed = value
-        .map((entry) => parseShortString(entry, maxLength))
-        .filter((entry) => entry !== undefined)
-        .slice(0, maxItems);
-    return parsed.length > 0 ? parsed : undefined;
-}
-function buildUserMessageMetadata(body, serverTimestamp, fallbackIntent) {
-    const rawMetadata = isRecord(body.messageMetadata) ? body.messageMetadata : {};
-    const rawComposition = isRecord(rawMetadata.composition)
-        ? rawMetadata.composition
-        : {};
-    const composition = {
-        typingStartedAt: parseIsoTimestamp(rawComposition.typingStartedAt),
-        typingEndedAt: parseIsoTimestamp(rawComposition.typingEndedAt),
-        lastEditedAt: parseIsoTimestamp(rawComposition.lastEditedAt),
-        submittedAt: parseIsoTimestamp(rawComposition.submittedAt),
+function recoveredPatientQueueItems(deps, sessionId) {
+    if (!deps.sessionQueuePersistenceService) {
+        return [];
+    }
+    return deps.sessionQueuePersistenceService
+        .listSession(sessionId)
+        .filter((item) => item.kind === "patient" && item.status === "paused-after-restart")
+        .sort((left, right) => left.queuedAt.localeCompare(right.queuedAt));
+}
+function sessionQueueSummaries(deps, sessionId, process) {
+    const recovered = recoveredPatientQueueSummaries(deps, sessionId);
+    if (process && typeof process.getDeferredQueueSummary === "function") {
+        const messages = [
+            ...process.getDeferredQueueSummary(),
+            ...recovered,
+        ];
+        return messages.sort((left, right) => (left.queuedAt ?? left.timestamp).localeCompare(right.queuedAt ?? right.timestamp));
+    }
+    if (process) {
+        return recovered;
+    }
+    return recovered;
+}
+function recoveredPatientUserMessage(item) {
+    const mode = item.message.mode ?? item.mode;
+    const metadata = {
+        ...item.message.metadata,
+        deliveryIntent: "patient",
     };
-    const cleanComposition = Object.fromEntries(Object.entries(composition).filter(([, value]) => value !== undefined));
-    const clientTimestamp = typeof body.clientTimestamp === "number" && Number.isFinite(body.clientTimestamp)
-        ? body.clientTimestamp
-        : undefined;
-    const rawSpeech = isRecord(rawMetadata.speech) ? rawMetadata.speech : {};
-    const speechClientTurnId = parseShortString(rawSpeech.clientTurnId, 120);
-    const speechTranscriptionIds = parseStringList(rawSpeech.transcriptionIds, 20, 120);
-    const speech = speechClientTurnId || speechTranscriptionIds
-        ? {
-            ...(speechClientTurnId
-                ? { clientTurnId: speechClientTurnId }
-                : {}),
-            ...(speechTranscriptionIds
-                ? { transcriptionIds: speechTranscriptionIds }
-                : {}),
-        }
-        : undefined;
+    // Live-queue chip actions (cancel, steer) address entries by tempId, so a
+    // recovered entry that was persisted without one gets a stable fallback.
+    const tempId = item.message.tempId ?? item.source?.tempId ?? `recovered-${item.id}`;
     return {
-        deliveryIntent: parseDeliveryIntent(rawMetadata.deliveryIntent) ?? fallbackIntent,
-        ...(Object.keys(cleanComposition).length > 0
-            ? { composition: cleanComposition }
-            : {}),
-        ...(speech ? { speech } : {}),
-        ...(clientTimestamp !== undefined ? { clientTimestamp } : {}),
-        serverReceivedAt: new Date(serverTimestamp).toISOString(),
+        ...item.message,
+        tempId,
+        ...(mode ? { mode } : {}),
+        metadata,
     };
 }
+/**
+ * Count live patient queue entries composed after the given recovered entry.
+ * Resuming or steering the recovered entry would deliver its older content
+ * behind these newer ones, so callers reject while any exist. Regular
+ * deferred entries never block recovered work: the regular lane delivers on
+ * turn boundaries and may pass patient work by design.
+ */
+function livePatientEntriesNewerThan(process, queuedAt) {
+    const live = process?.getDeferredQueueSummary() ?? [];
+    return live.filter((entry) => entry.metadata?.deliveryIntent === "patient" &&
+        entry.timestamp.localeCompare(queuedAt) > 0).length;
+}
+async function resolveSessionReaderForAgentContent({ deps, project, sessionId, projectId, }) {
+    const metadataProvider = deps.sessionMetadataService?.getProvider(sessionId);
+    const resolved = await findSessionSummaryAcrossProviders(project, sessionId, projectId, providerResolutionDeps(deps), metadataProvider, { readMode: "head" });
+    return resolved?.source.reader ?? deps.readerFactory(project);
+}
 const RESTART_HANDOFF_MAX_CHARS = 40_000;
 const RESTART_HANDOFF_JSON_MAX_CHARS = 2_000;
 const RESTART_HANDOFF_COMPACT_MAX_CHARS = 10_000;
@@ -336,7 +226,9 @@ function renderRestartContent(content) {
             case "text":
                 return typed.text ?? "";
             case "thinking":
-                return typed.thinking ? `[thinking]\n${typed.thinking}` : "[thinking]";
+                return typed.thinking
+                    ? `[thinking]\n${typed.thinking}`
+                    : "[thinking]";
             case "tool_use":
                 return `[tool_use ${typed.name ?? "unknown"}]\n${stringifyForRestart(typed.input, RESTART_HANDOFF_JSON_MAX_CHARS)}`;
             case "tool_result":
@@ -372,6 +264,33 @@ function messageContent(message) {
     const nested = message.message;
     return nested?.content ?? message.content;
 }
+function messageId(message) {
+    if (!message) {
+        return undefined;
+    }
+    return ((typeof message.uuid === "string" && message.uuid) ||
+        (typeof message.id === "string" && message.id) ||
+        undefined);
+}
+function findDurableRecapCursor(afterMessageId, recaps) {
+    if (!afterMessageId) {
+        return undefined;
+    }
+    return recaps.find((recap) => recap.uuid === afterMessageId || recap.id === afterMessageId);
+}
+function sliceAfterDurableRecapCursor(params) {
+    const index = params.messages.findIndex((message) => {
+        const id = messageId(message);
+        return (id === params.cursorId ||
+            id === params.recap.uuid ||
+            id === params.recap.id ||
+            hasEquivalentRecapMessage([message], params.recap));
+    });
+    if (index < 0) {
+        return { messages: params.messages, found: false };
+    }
+    return { messages: params.messages.slice(index + 1), found: true };
+}
 function messageHasToolResult(message) {
     if (message.toolUseResult !== undefined) {
         return true;
@@ -382,6 +301,32 @@ function messageHasToolResult(message) {
             typeof block === "object" &&
             block.type === "tool_result"));
 }
+function messageTextContent(message) {
+    const content = messageContent(message);
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return undefined;
+    }
+    const textBlocks = content
+        .map((block) => block &&
+        typeof block === "object" &&
+        block.type === "text" &&
+        typeof block.text === "string"
+        ? block.text
+        : "")
+        .filter(Boolean);
+    return textBlocks.length > 0 ? textBlocks.join("\n") : undefined;
+}
+function isSlashCommandSkillBodyUserMessage(message) {
+    if (message.isMeta !== true) {
+        return false;
+    }
+    return (messageTextContent(message)
+        ?.trimStart()
+        .startsWith("Base directory for this skill:") === true);
+}
 function isRestartInternalCompactCommand(message) {
     if (messageRole(message) !== "user" || messageHasToolResult(message)) {
         return false;
@@ -751,8 +696,111 @@ function isHumanUserMessage(message) {
         message.type;
     return role === "user" && !messageHasToolResult(message);
 }
+function isCompactSummaryUserMessage(message) {
+    return message.isCompactSummary === true;
+}
+function isUserAuthoredRequest(message) {
+    return (isHumanUserMessage(message) &&
+        !isCompactSummaryUserMessage(message) &&
+        !isSlashCommandSkillBodyUserMessage(message));
+}
+function resolveForkAfterBoundary(messages, sourceMessageId, sourceIsBusy) {
+    const sourceIndex = messages.findIndex((message) => messageId(message) === sourceMessageId);
+    const sourceMessage = messages[sourceIndex];
+    if (sourceIndex < 0 || !sourceMessage) {
+        return { error: "Selected source message was not found", status: 404 };
+    }
+    if (!isUserAuthoredRequest(sourceMessage)) {
+        return {
+            error: "sourceMessageId must identify a user-authored request",
+            status: 400,
+        };
+    }
+    let nextUserIndex = -1;
+    for (let index = sourceIndex + 1; index < messages.length; index += 1) {
+        const candidate = messages[index];
+        if (candidate && isUserAuthoredRequest(candidate)) {
+            nextUserIndex = index;
+            break;
+        }
+    }
+    if (nextUserIndex < 0 && sourceIsBusy) {
+        return {
+            error: "The selected turn is still in progress",
+            status: 409,
+        };
+    }
+    const searchEnd = nextUserIndex >= 0 ? nextUserIndex - 1 : messages.length - 1;
+    let hasAssistantResponse = false;
+    for (let index = sourceIndex + 1; index <= searchEnd; index += 1) {
+        const candidate = messages[index];
+        if (candidate && messageRole(candidate) === "assistant") {
+            hasAssistantResponse = true;
+            break;
+        }
+    }
+    if (!hasAssistantResponse) {
+        return {
+            error: "The selected request has no completed assistant response",
+            status: 409,
+        };
+    }
+    let boundary;
+    for (let index = searchEnd; index > sourceIndex; index -= 1) {
+        const candidate = messages[index];
+        const role = candidate ? messageRole(candidate) : undefined;
+        if (candidate &&
+            messageId(candidate) &&
+            (role === "user" || role === "assistant")) {
+            boundary = candidate;
+            break;
+        }
+    }
+    const retainedThroughMessageId = messageId(boundary);
+    if (!boundary || !retainedThroughMessageId) {
+        return { error: "Completed turn boundary has no message id", status: 409 };
+    }
+    const placementAfterMessageId = [...messages].reverse().map(messageId).find(Boolean) ??
+        retainedThroughMessageId;
+    const rendered = renderRestartContent(messageContent(boundary)).trim();
+    return {
+        placementAfterMessageId,
+        retainedThroughMessageId,
+        retainedThroughContext: rendered
+            ? truncateForRestart(rendered, 1200)
+            : undefined,
+    };
+}
+function forkSummaryTitle(summary, fallback) {
+    const firstLine = summary
+        .split("\n")
+        .map((line) => line.trim())
+        .find(Boolean);
+    const candidate = firstLine
+        ?.replace(/^#{1,6}\s*/u, "")
+        .replace(/^title:\s*/iu, "")
+        .trim()
+        .replace(/[.!?]+$/u, "");
+    return truncateSessionTitle(candidate || fallback || "Forked session");
+}
+function generatedRetitleCandidate(title) {
+    const firstLine = title
+        .split("\n")
+        .map((line) => line.trim())
+        .find(Boolean);
+    if (!firstLine) {
+        return undefined;
+    }
+    const candidate = normalizeRestartTitleCandidate(firstLine
+        .replace(/^title:\s*/iu, "")
+        .replace(/^["'“”‘’]+|["'“”‘’]+$/gu, "")
+        .replace(/[.!?]+$/u, "")
+        .trim());
+    return candidate ? truncateSessionTitle(candidate) : undefined;
+}
 function messageTitleCandidate(message) {
-    if (!isHumanUserMessage(message) || isRestartInternalCompactCommand(message)) {
+    if (!isHumanUserMessage(message) ||
+        isRestartInternalCompactCommand(message)) {
         return undefined;
     }
     const nested = message.message;
@@ -793,6 +841,18 @@ function deriveRestartTitle(params) {
     const title = /^Handoff:/i.test(base) ? base : `Handoff: ${base}`;
     return truncateRestartTitle(title);
 }
+function deriveForkTitle(params) {
+    const candidates = [
+        params.preferredTitle,
+        params.sourceSession.customTitle,
+        params.sourceSession.title,
+        latestUserTitleCandidate(params.sourceSession.messages),
+    ];
+    const base = candidates.map(normalizeRestartTitleCandidate).find(Boolean) ??
+        "forked session";
+    const title = /^Fork:/i.test(base) ? base : `Fork: ${base}`;
+    return truncateRestartTitle(title);
+}
 function buildRestartHandoff(params) {
     const { handoffTitle, sourceSession, sourceProvider, sourceModel, sourceProcess, compactAttempt, projectPath, reason, omittedCount, transcript, } = params;
     const oldProcessLine = sourceProcess
@@ -847,12 +907,14 @@ function isRestartReplacementActivity(message) {
 function sdkMessagesToClientMessages(sdkMessages) {
     const messages = [];
     for (const msg of sdkMessages) {
+        const rawFields = msg;
         if (isCompactBoundaryMessage(msg)) {
             const content = (typeof msg.message?.content === "string"
                 ? msg.message.content
                 : undefined) ??
                 (typeof msg.content === "string" ? msg.content : "Context compacted");
             messages.push({
+                ...rawFields,
                 id: msg.uuid ?? `msg-${Date.now()}-${messages.length}`,
                 type: "system",
                 role: "system",
@@ -889,6 +951,7 @@ function sdkMessagesToClientMessages(sdkMessages) {
                 continue;
             }
             messages.push({
+                ...rawFields,
                 id: msg.uuid ?? `msg-${Date.now()}-${messages.length}`,
                 type: msg.type,
                 role: msg.type,
@@ -1005,6 +1068,31 @@ function extractContextUsageFromSDKMessages(sdkMessages, model, provider, resolv
 }
 export function createSessionsRoutes(deps) {
     const routes = new Hono();
+    const activeForkSummaryJobs = new Map();
+    const emitTranscriptDisplayObjects = (sessionId) => {
+        deps.eventBus?.emit({
+            type: "session-metadata-changed",
+            sessionId,
+            transcriptDisplayObjects: deps.sessionMetadataService?.getTranscriptDisplayObjects(sessionId) ??
+                [],
+            timestamp: new Date().toISOString(),
+        });
+    };
+    const updateForkSummaryChildMetadata = async (childSessionId, parentSessionId, title, archived) => {
+        await deps.sessionMetadataService?.updateMetadata(childSessionId, {
+            title,
+            archived,
+            parentSessionId,
+        });
+        deps.eventBus?.emit({
+            type: "session-metadata-changed",
+            sessionId: childSessionId,
+            title,
+            archived,
+            parentSessionId,
+            timestamp: new Date().toISOString(),
+        });
+    };
     const getCodexReader = (projectPath) => deps.codexReaderFactory?.(projectPath) ??
         (deps.codexSessionsDir
             ? new CodexSessionReader({
@@ -1012,13 +1100,6 @@ export function createSessionsRoutes(deps) {
                 projectPath,
             })
             : null);
-    const getGrokReader = (projectPath) => deps.grokReaderFactory?.(projectPath) ??
-        (deps.grokSessionsDir
-            ? new GrokSessionReader({
-                sessionsDir: deps.grokSessionsDir,
-                projectPath,
-            })
-            : null);
     let unscopedGrokReader;
     const getUnscopedGrokReader = () => {
         if (unscopedGrokReader !== undefined) {
@@ -1045,8 +1126,78 @@ export function createSessionsRoutes(deps) {
         const search = new URL(requestUrl).search;
         return `/api/projects/${canonicalProjectId}/sessions/${encodeURIComponent(sessionId)}${suffix}${search}`;
     };
-    const getGlobalInstructions = () => deps.serverSettingsService?.getSetting("globalInstructions") || undefined;
-    const persistLaunchMetadata = async (sessionId, provider, executor, initialPrompt) => {
+    const buildSessionProjectRedirectPath = (canonicalProjectId, sessionId, suffix, requestUrl) => {
+        const search = new URL(requestUrl).search;
+        return `/api/projects/${canonicalProjectId}/sessions/${encodeURIComponent(sessionId)}${suffix}${search}`;
+    };
+    const resolveSessionProjectRouting = async (requestProjectId, sessionId) => {
+        const workingProjectId = deps.sessionMetadataService?.getMetadata(sessionId)?.workingProjectId;
+        if (workingProjectId && workingProjectId !== requestProjectId) {
+            return { redirectProjectId: workingProjectId };
+        }
+        const activeProcess = deps.supervisor.getProcessForSession(sessionId);
+        if (activeProcess &&
+            typeof activeProcess.projectId === "string" &&
+            isUrlProjectId(activeProcess.projectId) &&
+            activeProcess.projectId !== requestProjectId) {
+            return { redirectProjectId: activeProcess.projectId };
+        }
+        const workingProject = await deps.scanner.getOrCreateProject(requestProjectId);
+        if (!workingProject) {
+            return { error: "Project not found", status: 404 };
+        }
+        const metadata = deps.sessionMetadataService?.getMetadata(sessionId);
+        const transcriptProjectId = metadata?.workingProjectId === requestProjectId &&
+            metadata.transcriptProjectId
+            ? metadata.transcriptProjectId
+            : requestProjectId;
+        const transcriptProject = transcriptProjectId === requestProjectId
+            ? workingProject
+            : await deps.scanner.getOrCreateProject(transcriptProjectId);
+        if (!transcriptProject) {
+            return { error: "Transcript project not found", status: 404 };
+        }
+        return {
+            transcriptProject,
+            transcriptProjectId,
+            workingProject,
+            workingProjectId: requestProjectId,
+        };
+    };
+    const getGlobalInstructions = () => buildEffectiveAgentContext({
+        globalInstructions: deps.serverSettingsService?.getSetting("globalInstructions"),
+        hints: deps.serverSettingsService?.getSetting("agentContextHints"),
+    });
+    const resolveLaunchWorkstreamTarget = (project, rawWorkstreamId) => {
+        if (rawWorkstreamId === undefined) {
+            return { projectPath: project.path };
+        }
+        if (!isWorkstreamId(rawWorkstreamId)) {
+            return { error: "Invalid workstream ID format", status: 400 };
+        }
+        if (deps.serverSettingsService?.getSetting("workstreamsEnabled") !== true) {
+            return { error: "Workstreams are disabled", status: 404 };
+        }
+        if (!deps.workstreamService) {
+            return { error: "Workstreams unavailable", status: 503 };
+        }
+        const workstreamId = rawWorkstreamId;
+        if (workstreamId === mainWorkstreamId(project.id)) {
+            return { projectPath: project.path };
+        }
+        if (!deps.sessionMetadataService) {
+            return { error: "Session metadata unavailable", status: 503 };
+        }
+        const workstream = deps.workstreamService.getWorkstream(project.id, workstreamId);
+        if (workstream?.kind !== "checkout") {
+            return { error: "Workstream not found", status: 404 };
+        }
+        if (workstream.status !== "active") {
+            return { error: "Workstream is not active", status: 409 };
+        }
+        return { projectPath: workstream.path, workstreamId };
+    };
+    const persistLaunchMetadata = async (sessionId, provider, executor, initialPrompt, requestedModel, promptSuggestionMode, recapAfterSeconds, workstreamId) => {
         if (!deps.sessionMetadataService) {
             return;
         }
@@ -1059,18 +1210,40 @@ export function createSessionsRoutes(deps) {
         if (initialPrompt?.trim()) {
             await deps.sessionMetadataService.setInitialPrompt(sessionId, initialPrompt);
         }
+        // Persist the requested YA model id (the launch alias, incl. "default") so
+        // per-model settings still key by it after a server restart, instead of
+        // falling back to the reported model. See topics/provider-abstraction.md.
+        if (requestedModel) {
+            await deps.sessionMetadataService.setRequestedModel(sessionId, requestedModel);
+        }
+        // Persist the resolved prompt-suggestion mode so a later resume (which may
+        // omit it from the request body) recovers the per-session preference
+        // instead of falling back to the provider's native default.
+        if (promptSuggestionMode !== undefined) {
+            await deps.sessionMetadataService.updateMetadata(sessionId, {
+                promptSuggestionMode,
+            });
+        }
+        if (recapAfterSeconds !== undefined) {
+            await deps.sessionMetadataService.updateMetadata(sessionId, {
+                recapAfterSeconds,
+            });
+        }
+        if (workstreamId !== undefined) {
+            await deps.sessionMetadataService.setWorkstream(sessionId, workstreamId);
+        }
+    };
+    const loadProviderSession = async (project, sessionId, projectId, preferredProvider, afterMessageId, options) => {
+        for (const source of getSessionSources(project, providerResolutionDeps(deps), preferredProvider)) {
+            const loaded = await source.reader.getSession(sessionId, projectId, afterMessageId, options);
+            if (loaded) {
+                return loaded;
+            }
+        }
+        return null;
     };
     const loadRestartSourceSession = async (project, sessionId, projectId, preferredProvider, process) => {
-        const resolved = await findSessionSummaryAcrossProviders(project, sessionId, projectId, {
-            readerFactory: deps.readerFactory,
-            codexSessionsDir: deps.codexSessionsDir,
-            codexReaderFactory: deps.codexReaderFactory,
-            geminiSessionsDir: deps.geminiSessionsDir,
-            geminiReaderFactory: deps.geminiReaderFactory,
-            geminiHashToCwd: deps.geminiScanner?.getHashToCwd(),
-            grokSessionsDir: deps.grokSessionsDir,
-            grokReaderFactory: deps.grokReaderFactory,
-        }, preferredProvider);
+        const resolved = await findSessionSummaryAcrossProviders(project, sessionId, projectId, providerResolutionDeps(deps), preferredProvider, { readMode: "head" });
         if (resolved) {
             const loaded = await resolved.source.reader.getSession(sessionId, projectId, undefined, { includeOrphans: false });
             if (loaded) {
@@ -1092,6 +1265,7 @@ export function createSessionsRoutes(deps) {
                     processId: process.id,
                     permissionMode: process.permissionMode,
                     modeVersion: process.modeVersion,
+                    recapAfterSeconds: process.recapAfterSeconds,
                 },
                 provider: process.provider,
                 model: process.resolvedModel ?? process.model,
@@ -1127,7 +1301,8 @@ export function createSessionsRoutes(deps) {
             unsubscribe = null;
         };
         unsubscribe = replacement.subscribe((event) => {
-            if (event.type === "message" && isRestartReplacementActivity(event.message)) {
+            if (event.type === "message" &&
+                isRestartReplacementActivity(event.message)) {
                 cleanup();
                 void deps.supervisor.abortProcess(oldProcess.id).catch((error) => {
                     console.warn(`[restart] Failed to abort old process ${oldProcess.id}:`, error);
@@ -1157,11 +1332,19 @@ export function createSessionsRoutes(deps) {
         if (!isUrlProjectId(projectId)) {
             return c.json({ error: "Invalid project ID format" }, 400);
         }
-        const project = await deps.scanner.getOrCreateProject(projectId);
-        if (!project) {
-            return c.json({ error: "Project not found" }, 404);
+        const routing = await resolveSessionProjectRouting(projectId, c.req.param("sessionId"));
+        if ("redirectProjectId" in routing) {
+            return c.redirect(buildSessionProjectRedirectPath(routing.redirectProjectId, c.req.param("sessionId"), "", c.req.url), 307);
+        }
+        if ("error" in routing) {
+            return c.json({ error: routing.error }, routing.status);
         }
-        const reader = deps.readerFactory(project);
+        const reader = await resolveSessionReaderForAgentContent({
+            deps,
+            project: routing.transcriptProject,
+            sessionId: c.req.param("sessionId"),
+            projectId: routing.transcriptProjectId,
+        });
         const mappings = await reader.getAgentMappings();
         return c.json({ mappings });
     });
@@ -1174,17 +1357,30 @@ export function createSessionsRoutes(deps) {
         if (!isUrlProjectId(projectId)) {
             return c.json({ error: "Invalid project ID format" }, 400);
         }
-        const project = await deps.scanner.getOrCreateProject(projectId);
-        if (!project) {
-            return c.json({ error: "Project not found" }, 404);
+        const routing = await resolveSessionProjectRouting(projectId, c.req.param("sessionId"));
+        if ("redirectProjectId" in routing) {
+            return c.redirect(buildSessionProjectRedirectPath(routing.redirectProjectId, c.req.param("sessionId"), "", c.req.url), 307);
         }
-        const reader = deps.readerFactory(project);
+        if ("error" in routing) {
+            return c.json({ error: routing.error }, routing.status);
+        }
+        const reader = await resolveSessionReaderForAgentContent({
+            deps,
+            project: routing.transcriptProject,
+            sessionId: c.req.param("sessionId"),
+            projectId: routing.transcriptProjectId,
+        });
         const agentSession = await reader.getAgentSession(agentId);
         if (!agentSession) {
             return c.json({ error: "Agent session not found" }, 404);
         }
         // Add server-rendered HTML to text blocks for markdown display
-        await augmentTextBlocks(agentSession.messages);
+        await augmentTextBlocks(agentSession.messages, {
+            projectFileLinks: {
+                projectId: routing.workingProjectId,
+                projectPath: routing.workingProject.path,
+            },
+        });
         return c.json(agentSession);
     });
     // GET /api/projects/:projectId/sessions/:sessionId/metadata - Get session metadata only (no messages)
@@ -1196,10 +1392,16 @@ export function createSessionsRoutes(deps) {
         if (!isUrlProjectId(projectId)) {
             return c.json({ error: "Invalid project ID format" }, 400);
         }
-        const project = await deps.scanner.getOrCreateProject(projectId);
-        if (!project) {
-            return c.json({ error: "Project not found" }, 404);
+        const routing = await resolveSessionProjectRouting(projectId, sessionId);
+        if ("redirectProjectId" in routing) {
+            return c.redirect(buildSessionProjectRedirectPath(routing.redirectProjectId, sessionId, "/metadata", c.req.url), 307);
+        }
+        if ("error" in routing) {
+            return c.json({ error: routing.error }, routing.status);
         }
+        const project = routing.workingProject;
+        const transcriptProject = routing.transcriptProject;
+        const transcriptProjectId = routing.transcriptProjectId;
         // Check if session is actively owned by a process
         const process = deps.supervisor.getProcessForSession(sessionId);
         // Check if session is being controlled by an external program
@@ -1211,6 +1413,7 @@ export function createSessionsRoutes(deps) {
                 processId: process.id,
                 permissionMode: process.permissionMode,
                 modeVersion: process.modeVersion,
+                recapAfterSeconds: process.recapAfterSeconds,
             }
             : isExternal
                 ? { owner: "external" }
@@ -1222,23 +1425,18 @@ export function createSessionsRoutes(deps) {
         const lastSeenAt = lastSeenEntry?.timestamp;
         // Get pending input request from active process
         const pendingInputRequest = process?.state.type === "waiting-input" ? process.state.request : null;
-        // Get available slash commands from active process
-        const slashCommands = process?.supportsDynamicCommands
-            ? await process.supportedCommands()
-            : null;
+        const providerRuntimeStatus = process?.getProviderRuntimeStatus() ?? null;
         // Read minimal session info from disk (just for title/timestamps, no messages)
-        const metadataProvider = deps.sessionMetadataService?.getProvider(sessionId);
-        const sessionSummaryResult = await findSessionSummaryAcrossProviders(project, sessionId, projectId, {
-            readerFactory: deps.readerFactory,
-            codexSessionsDir: deps.codexSessionsDir,
-            codexReaderFactory: deps.codexReaderFactory,
-            geminiSessionsDir: deps.geminiSessionsDir,
-            geminiReaderFactory: deps.geminiReaderFactory,
-            geminiHashToCwd: deps.geminiScanner?.getHashToCwd(),
-            grokSessionsDir: deps.grokSessionsDir,
-            grokReaderFactory: deps.grokReaderFactory,
-        }, metadataProvider ?? process?.provider);
-        const sessionSummary = sessionSummaryResult?.summary ?? null;
+        const metadataProvider = metadata?.provider ??
+            deps.sessionMetadataService?.getProvider(sessionId);
+        const slashCommands = await getSessionSlashCommands(process, process?.provider ?? metadataProvider ?? project.provider);
+        const deferredMessages = sessionQueueSummaries(deps, sessionId, process);
+        const sessionSummaryResult = await findSessionSummaryAcrossProviders(transcriptProject, sessionId, transcriptProjectId, providerResolutionDeps(deps), metadataProvider ?? process?.provider);
+        const rawSessionSummary = sessionSummaryResult?.summary ?? null;
+        const recapMessages = deps.sessionMetadataService?.getRecapMessages?.(sessionId) ?? [];
+        const sessionSummary = rawSessionSummary
+            ? applyRecapOverlayToSummary(rawSessionSummary, recapMessages)
+            : null;
         if (!sessionSummary && !process) {
             const canonicalProjectId = await getGrokNativeProjectId(sessionId, projectId);
             if (canonicalProjectId) {
@@ -1246,14 +1444,13 @@ export function createSessionsRoutes(deps) {
             }
             return c.json({ error: "Session not found" }, 404);
         }
-        // Calculate hasUnread if we have session summary
-        const hasUnread = deps.notificationService && sessionSummary
-            ? deps.notificationService.hasUnread(sessionId, sessionSummary.updatedAt)
+        const hasUnread = rawSessionSummary
+            ? hasUnreadProviderContent(deps.notificationService, sessionId, rawSessionSummary.updatedAt)
             : undefined;
         const response = {
             session: {
                 id: sessionId,
-                projectId: projectId,
+                projectId: routing.workingProjectId,
                 title: sessionSummary?.title ?? null,
                 fullTitle: sessionSummary?.fullTitle ?? null,
                 createdAt: sessionSummary?.createdAt ?? new Date().toISOString(),
@@ -1279,16 +1476,142 @@ export function createSessionsRoutes(deps) {
                 heartbeatTurnsAfterMinutes: metadata?.heartbeatTurnsAfterMinutes,
                 heartbeatTurnText: metadata?.heartbeatTurnText,
                 heartbeatForceAfterMinutes: metadata?.heartbeatForceAfterMinutes ?? undefined,
+                promptSuggestionMode: metadata?.promptSuggestionMode,
+                recapAfterSeconds: metadata?.recapAfterSeconds,
+                workingProjectId: metadata?.workingProjectId,
+                transcriptProjectId: metadata?.transcriptProjectId,
+                workstreamId: metadata?.workstreamId,
+                transcriptDisplayObjects: metadata?.transcriptDisplayObjects,
                 lastSeenAt,
                 hasUnread,
             },
             ownership,
             processState: process?.state.type ?? null,
+            providerRuntimeStatus,
             pendingInputRequest,
             slashCommands,
+            ...(deferredMessages.length > 0 ? { deferredMessages } : {}),
         };
         return c.json(response);
     });
+    // PUT /api/projects/:projectId/sessions/:sessionId/project
+    // Reclassify a session under a different YA project without sending any
+    // provider-visible turn. The provider transcript remains under
+    // transcriptProjectId; relative file links and UI routing use projectId.
+    routes.put("/projects/:projectId/sessions/:sessionId/project", async (c) => {
+        const projectId = c.req.param("projectId");
+        const sessionId = c.req.param("sessionId");
+        if (!isUrlProjectId(projectId)) {
+            return c.json({ error: "Invalid project ID format" }, 400);
+        }
+        if (!deps.sessionMetadataService) {
+            return c.json({ error: "Session metadata service unavailable" }, 503);
+        }
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: "Invalid JSON body" }, 400);
+        }
+        const targetProjectId = body.projectId;
+        if (typeof targetProjectId !== "string" ||
+            !isUrlProjectId(targetProjectId)) {
+            return c.json({ error: "Invalid target project ID format" }, 400);
+        }
+        const targetProject = await deps.scanner.getOrCreateProject(targetProjectId);
+        if (!targetProject) {
+            return c.json({ error: "Target project not found" }, 404);
+        }
+        const metadata = deps.sessionMetadataService.getMetadata(sessionId);
+        const process = deps.supervisor.getProcessForSession(sessionId);
+        const transcriptProjectId = metadata?.transcriptProjectId ??
+            process?.projectId ??
+            projectId;
+        const transcriptProject = transcriptProjectId === targetProjectId
+            ? targetProject
+            : await deps.scanner.getOrCreateProject(transcriptProjectId);
+        if (!transcriptProject) {
+            return c.json({ error: "Transcript project not found" }, 404);
+        }
+        if (!process) {
+            const metadataProvider = metadata?.provider ??
+                deps.sessionMetadataService.getProvider(sessionId);
+            const summary = await findSessionSummaryAcrossProviders(transcriptProject, sessionId, transcriptProjectId, providerResolutionDeps(deps), metadataProvider, { readMode: "head" });
+            if (!summary) {
+                return c.json({ error: "Session not found" }, 404);
+            }
+        }
+        const storedWorkingProjectId = targetProjectId === transcriptProjectId ? undefined : targetProjectId;
+        const storedTranscriptProjectId = targetProjectId === transcriptProjectId ? undefined : transcriptProjectId;
+        await deps.sessionMetadataService.setWorkingProject(sessionId, storedWorkingProjectId, storedTranscriptProjectId);
+        deps.eventBus?.emit({
+            type: "session-metadata-changed",
+            sessionId,
+            projectId: targetProjectId,
+            transcriptProjectId: storedTranscriptProjectId ?? null,
+            timestamp: new Date().toISOString(),
+        });
+        return c.json({
+            updated: true,
+            projectId: targetProjectId,
+            transcriptProjectId: storedTranscriptProjectId ?? null,
+        });
+    });
+    // POST /api/projects/:projectId/sessions/:sessionId/refresh-preview
+    // On-demand recompute of the hover-card recent-activity excerpt for a
+    // non-running session (its live state is otherwise only refreshed when the
+    // session is resumed). Fast reverse-scan of the JSONL, then push the result
+    // to lists/hovers via a session-updated event so the preview updates in
+    // place without flicker. See topics/session-hovercard-recent-activity.md.
+    routes.post("/projects/:projectId/sessions/:sessionId/refresh-preview", async (c) => {
+        const projectId = c.req.param("projectId");
+        const sessionId = c.req.param("sessionId");
+        if (!isUrlProjectId(projectId)) {
+            return c.json({ error: "Invalid project ID format" }, 400);
+        }
+        const routing = await resolveSessionProjectRouting(projectId, sessionId);
+        if ("redirectProjectId" in routing) {
+            return c.redirect(buildSessionProjectRedirectPath(routing.redirectProjectId, sessionId, "/refresh-preview", c.req.url), 307);
+        }
+        if ("error" in routing) {
+            return c.json({ error: routing.error }, routing.status);
+        }
+        const transcriptProject = routing.transcriptProject;
+        const transcriptProjectId = routing.transcriptProjectId;
+        const metadataProvider = deps.sessionMetadataService?.getProvider(sessionId);
+        const recapMessages = deps.sessionMetadataService?.getRecapMessages?.(sessionId) ?? [];
+        let lastAgentText;
+        if (recapMessages.length > 0) {
+            const summaryResult = await findSessionSummaryAcrossProviders(transcriptProject, sessionId, transcriptProjectId, providerResolutionDeps(deps), metadataProvider);
+            if (summaryResult?.summary) {
+                lastAgentText = applyRecapOverlayToSummary(summaryResult.summary, recapMessages).lastAgentText;
+            }
+        }
+        // Claude uses the fast reverse-scan when there is no durable overlay to
+        // compare; every other provider goes through the cross-provider load +
+        // normalize, then a shared extractor on the uniform message form.
+        const reader = deps.readerFactory(transcriptProject);
+        lastAgentText ??= reader.getLastAgentExcerpt
+            ? await reader.getLastAgentExcerpt(sessionId)
+            : undefined;
+        if (lastAgentText === undefined) {
+            const normalized = await loadRestartSourceSession(transcriptProject, sessionId, transcriptProjectId, metadataProvider);
+            if (normalized) {
+                lastAgentText = extractLastAgentExcerpt(normalized.messages);
+            }
+        }
+        if (lastAgentText !== undefined) {
+            deps.eventBus?.emit({
+                type: "session-updated",
+                sessionId,
+                projectId: routing.workingProjectId,
+                lastAgentText,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        return c.json({ lastAgentText: lastAgentText ?? null });
+    });
     // GET /api/projects/:projectId/sessions/:sessionId - Get session detail
     // Optional query params:
     //   ?afterMessageId=<id> - incremental forward-fetch (append new messages)
@@ -1296,12 +1619,15 @@ export function createSessionsRoutes(deps) {
     //   ?beforeMessageId=<id> - cursor for loading older chunks (used with tailCompactions)
     //   ?tailTurns=<n> - aggressive opt-in client memory cap by recent user turns
     //   ?tailFrom=<id> - aggressive opt-in client memory cap from a user message id
+    //   ?fullHistory=1 - explicit opt-in to the full transcript
     routes.get("/projects/:projectId/sessions/:sessionId", async (c) => {
         const requestStartMs = performance.now();
         const projectId = c.req.param("projectId");
         const sessionId = c.req.param("sessionId");
         const afterMessageId = c.req.query("afterMessageId");
         const publicShare = c.req.query("publicShare") === "1";
+        const fullHistory = c.req.query("fullHistory") === "1";
+        const fullHistoryReason = c.req.query("fullHistoryReason");
         const tailCompactionsParam = c.req.query("tailCompactions");
         const beforeMessageId = c.req.query("beforeMessageId");
         const tailTurnsParam = c.req.query("tailTurns");
@@ -1312,15 +1638,38 @@ export function createSessionsRoutes(deps) {
         const tailTurns = tailTurnsParam !== undefined
             ? Number.parseInt(tailTurnsParam, 10)
             : undefined;
+        const requestedTailCompactions = tailCompactions !== undefined &&
+            !Number.isNaN(tailCompactions) &&
+            tailCompactions > 0
+            ? tailCompactions
+            : undefined;
+        const requestedTailTurns = tailTurns !== undefined && !Number.isNaN(tailTurns) && tailTurns > 0
+            ? tailTurns
+            : undefined;
+        const defaultedToCompactTail = !fullHistory &&
+            !afterMessageId &&
+            !tailFrom &&
+            requestedTailTurns === undefined &&
+            requestedTailCompactions === undefined;
+        const effectiveTailCompactions = requestedTailCompactions ??
+            (defaultedToCompactTail
+                ? DEFAULT_SESSION_DETAIL_TAIL_COMPACTIONS
+                : undefined);
         // Validate projectId format at API boundary
         if (!isUrlProjectId(projectId)) {
             return c.json({ error: "Invalid project ID format" }, 400);
         }
-        // Use getOrCreateProject to support Codex projects that may not be in the scan cache yet
-        const project = await deps.scanner.getOrCreateProject(projectId);
-        if (!project) {
-            return c.json({ error: "Project not found" }, 404);
+        const routing = await resolveSessionProjectRouting(projectId, sessionId);
+        if ("redirectProjectId" in routing) {
+            return c.redirect(buildSessionProjectRedirectPath(routing.redirectProjectId, sessionId, "", c.req.url), 307);
         }
+        if ("error" in routing) {
+            return c.json({ error: routing.error }, routing.status);
+        }
+        const project = routing.workingProject;
+        const effectiveProjectId = routing.workingProjectId;
+        const transcriptProject = routing.transcriptProject;
+        const transcriptProjectId = routing.transcriptProjectId;
         const projectResolvedMs = performance.now();
         // Check if session is actively owned by a process
         const process = deps.supervisor.getProcessForSession(sessionId);
@@ -1330,70 +1679,30 @@ export function createSessionsRoutes(deps) {
         // Only mark tools as "aborted" if we owned the session and know it terminated
         const wasEverOwned = deps.supervisor.wasEverOwned(sessionId);
         const metadataProvider = deps.sessionMetadataService?.getProvider(sessionId);
-        // Always try to read from disk first (even for owned sessions)
-        const reader = deps.readerFactory(project);
-        let loadedSession = await reader.getSession(sessionId, project.id, afterMessageId, {
+        const recapMessages = deps.sessionMetadataService?.getRecapMessages?.(sessionId) ?? [];
+        const recapCursor = findDurableRecapCursor(afterMessageId, recapMessages);
+        const providerAfterMessageId = recapCursor ? undefined : afterMessageId;
+        const primaryReaderAfterMessageId = isClaudeSdkProviderName(project.provider) ||
+            isClaudeSdkProviderName(metadataProvider)
+            ? undefined
+            : providerAfterMessageId;
+        const loadedSession = await loadProviderSession(transcriptProject, sessionId, transcriptProjectId, metadataProvider ?? process?.provider, primaryReaderAfterMessageId, {
             // Only include orphaned tool info if:
             // 1. We previously owned this session (not external)
             // 2. No active process (tools aren't potentially in progress)
             // When we own the session, tools without results might be pending approval
             includeOrphans: wasEverOwned && !process,
         });
-        // For Claude projects, also check for Codex sessions if primary reader didn't find it
-        // This handles mixed projects that have sessions from multiple providers
-        if (!loadedSession &&
-            project.provider === "claude" &&
-            (deps.codexReaderFactory || deps.codexSessionsDir)) {
-            const codexReader = deps.codexReaderFactory?.(project.path) ??
-                (deps.codexSessionsDir
-                    ? new CodexSessionReader({
-                        sessionsDir: deps.codexSessionsDir,
-                        projectPath: project.path,
-                    })
-                    : null);
-            if (codexReader) {
-                loadedSession = await codexReader.getSession(sessionId, project.id, afterMessageId, { includeOrphans: wasEverOwned && !process });
-            }
-        }
-        // For Claude/Codex projects, also check for Gemini sessions if still not found
-        // This handles mixed projects that have sessions from multiple providers
-        if (!loadedSession &&
-            (project.provider === "claude" || project.provider === "codex") &&
-            (deps.geminiReaderFactory || deps.geminiSessionsDir)) {
-            const geminiReader = deps.geminiReaderFactory?.(project.path) ??
-                (deps.geminiSessionsDir
-                    ? new GeminiSessionReader({
-                        sessionsDir: deps.geminiSessionsDir,
-                        projectPath: project.path,
-                        hashToCwd: deps.geminiScanner?.getHashToCwd(),
-                    })
-                    : null);
-            if (geminiReader) {
-                loadedSession = await geminiReader.getSession(sessionId, project.id, afterMessageId, { includeOrphans: wasEverOwned && !process });
-            }
-        }
-        // For mixed-provider projects, a restarted YA process may need session
-        // metadata to rediscover an OpenCode-native ses_* transcript.
-        if (!loadedSession && metadataProvider === "opencode") {
-            const opencodeReader = deps.readerFactory({
-                ...project,
-                provider: "opencode",
-            });
-            loadedSession = await opencodeReader.getSession(sessionId, project.id, afterMessageId, { includeOrphans: wasEverOwned && !process });
-        }
-        if (!loadedSession) {
-            const grokReader = getGrokReader(project.path);
-            if (grokReader) {
-                loadedSession = await grokReader.getSession(sessionId, project.id, afterMessageId, { includeOrphans: wasEverOwned && !process });
-            }
-        }
         const readEndMs = performance.now();
         let session = loadedSession ? normalizeSession(loadedSession) : null;
         const normalizedMessageCount = session?.messages.length ?? 0;
         const normalizeEndMs = performance.now();
+        if (session && isClaudeSdkProviderName(session.provider)) {
+            augmentTaskListSnapshots(session.messages);
+        }
         let incrementalAnchorFound = false;
-        if (session && afterMessageId) {
-            const sliced = sliceAfterMessageIdWithMatch(session.messages, afterMessageId);
+        if (session && providerAfterMessageId) {
+            const sliced = sliceAfterMessageIdWithMatch(session.messages, providerAfterMessageId);
             session = {
                 ...session,
                 messages: sliced.messages,
@@ -1407,6 +1716,7 @@ export function createSessionsRoutes(deps) {
                 processId: process.id,
                 permissionMode: process.permissionMode,
                 modeVersion: process.modeVersion,
+                recapAfterSeconds: process.recapAfterSeconds,
             }
             : isExternal
                 ? { owner: "external" }
@@ -1414,12 +1724,16 @@ export function createSessionsRoutes(deps) {
         // Get pending input request from active process (for tool approval prompts)
         // This ensures clients get pending requests immediately without waiting for SSE
         const pendingInputRequest = process?.state.type === "waiting-input" ? process.state.request : null;
-        // Get available slash commands from active process (for "/" button in toolbar)
+        const providerRuntimeStatus = process?.getProviderRuntimeStatus() ?? null;
+        // Get available slash commands (for "/" button and typed slash menu)
         // The init message that normally carries these gets discarded from the SSE buffer
-        // after ~30s, so we attach them to the REST response for reliable delivery.
-        const slashCommands = process?.supportsDynamicCommands
-            ? await process.supportedCommands()
-            : null;
+        // after ~30s, so we attach them to the REST response. Providers with known
+        // native built-ins, such as Codex, can expose those while stopped.
+        const slashCommands = await getSessionSlashCommands(process, process?.provider ??
+            session?.provider ??
+            metadataProvider ??
+            project.provider);
+        const deferredMessages = sessionQueueSummaries(deps, sessionId, process);
         if (!session) {
             // Session file doesn't exist yet - only valid if we own the process
             if (process) {
@@ -1436,22 +1750,23 @@ export function createSessionsRoutes(deps) {
                     : mis
                         ? (m, p) => mis.getContextWindow(m, p)
                         : undefined);
-                // Cache SDK-reported context window for future JSONL reads
-                if (mis && sdkContextWindow && process.resolvedModel) {
-                    mis.recordContextWindow(process.resolvedModel, sdkContextWindow, process.provider);
-                }
+                // (Durable recording happens at the observation point in Process via
+                // onContextWindowObserved, not as a side effect of this GET.)
                 // Get metadata even for new sessions (in case it was set before file was written)
                 const metadata = deps.sessionMetadataService?.getMetadata(sessionId);
+                const recapMessages = deps.sessionMetadataService?.getRecapMessages?.(sessionId) ?? [];
+                const visibleProcessMessages = mergeRecapMessages(processMessages, recapMessages);
                 // Get notification data for new sessions too
                 const lastSeenEntry = deps.notificationService?.getLastSeen(sessionId);
-                const newSessionUpdatedAt = new Date().toISOString();
+                const latestRecap = latestRecapMessage(recapMessages);
+                const newSessionUpdatedAt = latestRecap?.timestamp ?? new Date().toISOString();
                 const hasUnread = deps.notificationService
                     ? deps.notificationService.hasUnread(sessionId, newSessionUpdatedAt)
                     : undefined;
                 return c.json({
                     session: {
                         id: sessionId,
-                        projectId,
+                        projectId: effectiveProjectId,
                         title: null,
                         createdAt: new Date().toISOString(),
                         updatedAt: newSessionUpdatedAt,
@@ -1466,16 +1781,24 @@ export function createSessionsRoutes(deps) {
                         heartbeatTurnsAfterMinutes: metadata?.heartbeatTurnsAfterMinutes,
                         heartbeatTurnText: metadata?.heartbeatTurnText,
                         heartbeatForceAfterMinutes: metadata?.heartbeatForceAfterMinutes,
+                        promptSuggestionMode: metadata?.promptSuggestionMode,
+                        recapAfterSeconds: metadata?.recapAfterSeconds,
+                        workingProjectId: metadata?.workingProjectId,
+                        transcriptProjectId: metadata?.transcriptProjectId,
+                        workstreamId: metadata?.workstreamId,
+                        transcriptDisplayObjects: metadata?.transcriptDisplayObjects,
                         lastSeenAt: lastSeenEntry?.timestamp,
                         hasUnread,
                         provider: process.provider,
                         model: process.resolvedModel,
                         contextUsage,
                     },
-                    messages: processMessages,
+                    messages: visibleProcessMessages,
                     ownership,
+                    providerRuntimeStatus,
                     pendingInputRequest,
                     slashCommands,
+                    ...(deferredMessages.length > 0 ? { deferredMessages } : {}),
                 });
             }
             const canonicalProjectId = await getGrokNativeProjectId(sessionId, projectId);
@@ -1489,37 +1812,32 @@ export function createSessionsRoutes(deps) {
         // Get notification data (lastSeenAt, hasUnread)
         const lastSeenEntry = deps.notificationService?.getLastSeen(sessionId);
         const lastSeenAt = lastSeenEntry?.timestamp;
-        const hasUnread = deps.notificationService
-            ? deps.notificationService.hasUnread(sessionId, session.updatedAt)
-            : undefined;
         // Apply pagination if requested (BEFORE expensive augmentation). tailTurns
         // is an opt-in stronger client memory cap, so it wins over compact tails.
         // Skip both when afterMessageId is present since that's an incremental
         // forward-fetch use case.
         let paginationInfo;
         if (!afterMessageId &&
-            (tailFrom ||
-                (tailTurns !== undefined && !Number.isNaN(tailTurns) && tailTurns > 0))) {
-            const sliced = sliceAtUserTurnBoundary(session.messages, tailTurns !== undefined && !Number.isNaN(tailTurns) && tailTurns > 0
-                ? tailTurns
-                : 20, tailFrom);
+            (tailFrom || requestedTailTurns !== undefined)) {
+            const sliced = sliceAtUserTurnBoundary(session.messages, requestedTailTurns ?? 20, tailFrom);
             session = { ...session, messages: sliced.messages };
             paginationInfo = sliced.pagination;
         }
-        else if (tailCompactions !== undefined &&
-            !Number.isNaN(tailCompactions) &&
-            tailCompactions > 0 &&
+        else if (effectiveTailCompactions !== undefined &&
             !afterMessageId) {
-            const sliced = sliceAtCompactBoundaries(session.messages, tailCompactions, beforeMessageId);
+            const sliced = sliceAtCompactBoundaries(session.messages, effectiveTailCompactions, beforeMessageId);
             session = { ...session, messages: sliced.messages };
             paginationInfo = sliced.pagination;
         }
+        if (isClaudeSdkProviderName(session.provider)) {
+            pruneTaskListSnapshotsToLatest(session.messages);
+        }
         const sliceEndMs = performance.now();
         // Codex normalized IDs can drift between stream and JSONL. If an
         // incremental request misses its anchor, never return the full historical
         // session into a compact-tail client; bound the fallback to the same tail
         // window used for initial loads.
-        if (afterMessageId && !incrementalAnchorFound) {
+        if (providerAfterMessageId && !incrementalAnchorFound) {
             const sliced = sliceAtCompactBoundaries(session.messages, 2);
             session = { ...session, messages: sliced.messages };
             paginationInfo = sliced.pagination;
@@ -1529,9 +1847,33 @@ export function createSessionsRoutes(deps) {
             await augmentEditToolUses(session.messages);
         }
         else {
-            await augmentPersistedSessionMessages(session.messages);
+            await augmentPersistedSessionMessages(session.messages, {
+                projectFileLinks: {
+                    projectId: effectiveProjectId,
+                    projectPath: project.path,
+                },
+            });
+        }
+        // The overlay reassigns `session` below; hasUnreadProviderContent needs
+        // the pre-overlay timestamp.
+        const preRecapUpdatedAt = session.updatedAt;
+        if (!beforeMessageId) {
+            session = applyRecapOverlayToSession(session, recapMessages);
+            if (recapCursor && afterMessageId) {
+                const sliced = sliceAfterDurableRecapCursor({
+                    messages: session.messages,
+                    recap: recapCursor,
+                    cursorId: afterMessageId,
+                });
+                session = { ...session, messages: sliced.messages };
+                incrementalAnchorFound = sliced.found;
+            }
+        }
+        else {
+            session = applyRecapOverlayToSummary(session, recapMessages);
         }
         const augmentEndMs = performance.now();
+        const hasUnread = hasUnreadProviderContent(deps.notificationService, sessionId, preRecapUpdatedAt);
         // Override context usage with SDK-reported context window from live process
         // The reader uses hardcoded defaults; the process captures the real value at runtime
         let { contextUsage } = session;
@@ -1542,29 +1884,80 @@ export function createSessionsRoutes(deps) {
                 percentage: Math.round((contextUsage.inputTokens / cw) * 100),
                 contextWindow: cw,
             };
-            // Cache for future reads without a live process
-            deps.modelInfoService?.recordContextWindow(process.resolvedModel ?? session.model ?? "", cw, process.provider);
+            // Durable recording happens at the observation point in Process via
+            // onContextWindowObserved; this block only overrides the displayed value.
         }
         const { messages: _messages, ...sessionMetadata } = session;
         const totalMs = performance.now() - requestStartMs;
+        if (defaultedToCompactTail &&
+            normalizedMessageCount >= LARGE_FULL_HISTORY_MESSAGE_THRESHOLD) {
+            getLogger().warn({
+                beforeMessageId: beforeMessageId ?? null,
+                defaultTailCompactions: DEFAULT_SESSION_DETAIL_TAIL_COMPACTIONS,
+                event: "session_detail_unbounded_defaulted_to_tail",
+                normalizedMessageCount,
+                projectId: effectiveProjectId,
+                transcriptProjectId,
+                provider: session.provider,
+                publicShare,
+                returnedMessageCount: session.messages.length,
+                sessionId,
+                timings: {
+                    augmentMs: roundedMs(augmentEndMs - sliceEndMs),
+                    normalizeMs: roundedMs(normalizeEndMs - readEndMs),
+                    projectMs: roundedMs(projectResolvedMs - requestStartMs),
+                    readMs: roundedMs(readEndMs - projectResolvedMs),
+                    routeMs: roundedMs(sliceEndMs - normalizeEndMs),
+                    totalMs: roundedMs(totalMs),
+                },
+                totalMessageCount: session.messageCount,
+            }, "SESSION_DETAIL: defaulted unbounded request to compact tail");
+        }
+        if (fullHistory &&
+            session.messages.length >= LARGE_FULL_HISTORY_MESSAGE_THRESHOLD) {
+            getLogger().warn({
+                event: "session_detail_full_history_large",
+                fullHistoryReason: fullHistoryReason ?? null,
+                normalizedMessageCount,
+                projectId: effectiveProjectId,
+                transcriptProjectId,
+                provider: session.provider,
+                publicShare,
+                returnedMessageCount: session.messages.length,
+                sessionId,
+                timings: {
+                    augmentMs: roundedMs(augmentEndMs - sliceEndMs),
+                    normalizeMs: roundedMs(normalizeEndMs - readEndMs),
+                    projectMs: roundedMs(projectResolvedMs - requestStartMs),
+                    readMs: roundedMs(readEndMs - projectResolvedMs),
+                    routeMs: roundedMs(sliceEndMs - normalizeEndMs),
+                    totalMs: roundedMs(totalMs),
+                },
+                totalMessageCount: session.messageCount,
+            }, "SESSION_DETAIL: large explicit full-history request");
+        }
         if (totalMs >= SESSION_DETAIL_SLOW_LOG_MS) {
             getLogger().warn({
                 afterMessageId: afterMessageId ?? null,
                 beforeMessageId: beforeMessageId ?? null,
                 event: "session_detail_slow",
+                defaultedToCompactTail,
+                fullHistory,
+                fullHistoryReason: fullHistoryReason ?? null,
                 incrementalAnchorFound: afterMessageId
                     ? incrementalAnchorFound
                     : null,
                 normalizedMessageCount,
                 owned: Boolean(process),
                 processState: process?.state.type ?? null,
-                projectId,
+                projectId: effectiveProjectId,
+                transcriptProjectId,
                 provider: session.provider,
                 publicShare,
                 returnedMessageCount: session.messages.length,
                 sessionId,
-                tailCompactions: tailCompactions ?? null,
-                tailTurns: tailTurns ?? null,
+                tailCompactions: effectiveTailCompactions ?? null,
+                tailTurns: requestedTailTurns ?? null,
                 timings: {
                     augmentMs: roundedMs(augmentEndMs - sliceEndMs),
                     normalizeMs: roundedMs(normalizeEndMs - readEndMs),
@@ -1579,6 +1972,7 @@ export function createSessionsRoutes(deps) {
         return c.json({
             session: {
                 ...sessionMetadata,
+                projectId: effectiveProjectId,
                 ownership,
                 contextUsage,
                 customTitle: metadata?.customTitle,
@@ -1590,6 +1984,12 @@ export function createSessionsRoutes(deps) {
                 heartbeatTurnsAfterMinutes: metadata?.heartbeatTurnsAfterMinutes,
                 heartbeatTurnText: metadata?.heartbeatTurnText,
                 heartbeatForceAfterMinutes: metadata?.heartbeatForceAfterMinutes,
+                promptSuggestionMode: metadata?.promptSuggestionMode,
+                recapAfterSeconds: metadata?.recapAfterSeconds,
+                workingProjectId: metadata?.workingProjectId,
+                transcriptProjectId: metadata?.transcriptProjectId,
+                workstreamId: metadata?.workstreamId,
+                transcriptDisplayObjects: metadata?.transcriptDisplayObjects,
                 // Model comes from the session reader (extracted from JSONL)
                 model: session.model,
                 lastSeenAt,
@@ -1597,9 +1997,11 @@ export function createSessionsRoutes(deps) {
             },
             messages: session.messages,
             ownership,
+            providerRuntimeStatus,
             pendingInputRequest,
             slashCommands,
             ...(paginationInfo && { pagination: paginationInfo }),
+            ...(deferredMessages.length > 0 ? { deferredMessages } : {}),
         });
     });
     // POST /api/projects/:projectId/sessions - Start new session
@@ -1632,6 +2034,10 @@ export function createSessionsRoutes(deps) {
         if (helperSettings.error) {
             return c.json({ error: helperSettings.error }, 400);
         }
+        const workstreamTarget = resolveLaunchWorkstreamTarget(project, body.workstreamId);
+        if ("error" in workstreamTarget) {
+            return c.json({ error: workstreamTarget.error }, workstreamTarget.status);
+        }
         const serverTimestamp = Date.now();
         const userMessage = {
             text: body.message,
@@ -1644,7 +2050,7 @@ export function createSessionsRoutes(deps) {
         };
         // Convert thinking option to SDK config
         const { thinking, effort } = body.thinking
-            ? thinkingOptionToConfig(body.thinking)
+            ? thinkingOptionToConfig(body.thinking, body.showThinking)
             : { thinking: undefined, effort: undefined };
         // Convert model option (undefined or "default" means use CLI default)
         const model = body.model && body.model !== "default" ? body.model : undefined;
@@ -1656,7 +2062,7 @@ export function createSessionsRoutes(deps) {
             model: body.model,
             serviceTier,
         });
-        const result = await deps.supervisor.startSession(project.path, userMessage, body.mode, {
+        const result = await deps.supervisor.startSession(workstreamTarget.projectPath, userMessage, body.mode, {
             model,
             serviceTier,
             thinking,
@@ -1666,8 +2072,12 @@ export function createSessionsRoutes(deps) {
             globalInstructions: getGlobalInstructions(),
             permissions: body.permissions,
             recapMode: helperSettings.recapMode,
+            recapAfterSeconds: helperSettings.recapAfterSeconds,
             promptSuggestionMode: helperSettings.promptSuggestionMode,
             helperSideModel: helperSettings.helperSideModel,
+        }, {
+            projectId: project.id,
+            workstreamId: workstreamTarget.workstreamId,
         });
         // Check if queue is full
         if (isQueueFullResponse(result)) {
@@ -1677,13 +2087,14 @@ export function createSessionsRoutes(deps) {
         if (isQueuedResponse(result)) {
             return c.json({ ...result, serverTimestamp }, 202); // 202 Accepted - queued for processing
         }
-        await persistLaunchMetadata(result.sessionId, body.provider, executor, body.message);
+        await persistLaunchMetadata(result.sessionId, body.provider, executor, body.message, body.model, result.promptSuggestionMode, helperSettings.recapAfterSeconds, workstreamTarget.workstreamId);
         return c.json({
             sessionId: result.sessionId,
             processId: result.id,
             projectId: result.projectId,
             permissionMode: result.permissionMode,
             modeVersion: result.modeVersion,
+            recapAfterSeconds: result.recapAfterSeconds,
             serverTimestamp,
         });
     });
@@ -1715,14 +2126,18 @@ export function createSessionsRoutes(deps) {
         if (helperSettings.error) {
             return c.json({ error: helperSettings.error }, 400);
         }
+        const workstreamTarget = resolveLaunchWorkstreamTarget(project, body.workstreamId);
+        if ("error" in workstreamTarget) {
+            return c.json({ error: workstreamTarget.error }, workstreamTarget.status);
+        }
         // Convert thinking option to SDK config
         const { thinking, effort } = body.thinking
-            ? thinkingOptionToConfig(body.thinking)
+            ? thinkingOptionToConfig(body.thinking, body.showThinking)
             : { thinking: undefined, effort: undefined };
         // Convert model option (undefined or "default" means use CLI default)
         const model = body.model && body.model !== "default" ? body.model : undefined;
         const serviceTier = normalizeOptionalServiceTier(body.serviceTier);
-        const result = await deps.supervisor.createSession(project.path, body.mode, {
+        const result = await deps.supervisor.createSession(workstreamTarget.projectPath, body.mode, {
             model,
             serviceTier,
             thinking,
@@ -1732,8 +2147,12 @@ export function createSessionsRoutes(deps) {
             globalInstructions: getGlobalInstructions(),
             permissions: body.permissions,
             recapMode: helperSettings.recapMode,
+            recapAfterSeconds: helperSettings.recapAfterSeconds,
             promptSuggestionMode: helperSettings.promptSuggestionMode,
             helperSideModel: helperSettings.helperSideModel,
+        }, {
+            projectId: project.id,
+            workstreamId: workstreamTarget.workstreamId,
         });
         // Check if queue is full
         if (isQueueFullResponse(result)) {
@@ -1743,13 +2162,14 @@ export function createSessionsRoutes(deps) {
         if (isQueuedResponse(result)) {
             return c.json({ ...result, serverTimestamp: Date.now() }, 202); // 202 Accepted - queued for processing
         }
-        await persistLaunchMetadata(result.sessionId, body.provider, executor);
+        await persistLaunchMetadata(result.sessionId, body.provider, executor, undefined, body.model, result.promptSuggestionMode, helperSettings.recapAfterSeconds, workstreamTarget.workstreamId);
         return c.json({
             sessionId: result.sessionId,
             processId: result.id,
             projectId: result.projectId,
             permissionMode: result.permissionMode,
             modeVersion: result.modeVersion,
+            recapAfterSeconds: result.recapAfterSeconds,
             serverTimestamp: Date.now(),
         });
     });
@@ -1785,7 +2205,7 @@ export function createSessionsRoutes(deps) {
             metadata: buildUserMessageMetadata(body, serverTimestamp, "direct"),
         };
         const { thinking, effort } = body.thinking
-            ? thinkingOptionToConfig(body.thinking)
+            ? thinkingOptionToConfig(body.thinking, body.showThinking)
             : { thinking: undefined, effort: undefined };
         const model = body.model && body.model !== "default" ? body.model : undefined;
         const serviceTier = normalizeOptionalServiceTier(body.serviceTier);
@@ -1799,6 +2219,7 @@ export function createSessionsRoutes(deps) {
             globalInstructions: getGlobalInstructions(),
             permissions: body.permissions,
             recapMode: helperSettings.recapMode,
+            recapAfterSeconds: helperSettings.recapAfterSeconds,
             promptSuggestionMode: helperSettings.promptSuggestionMode,
             helperSideModel: helperSettings.helperSideModel,
         });
@@ -1808,13 +2229,14 @@ export function createSessionsRoutes(deps) {
         if (isQueuedResponse(result)) {
             return c.json({ ...result, serverTimestamp: Date.now() }, 202);
         }
-        await persistLaunchMetadata(result.sessionId, body.provider, executor, body.message);
+        await persistLaunchMetadata(result.sessionId, body.provider, executor, body.message, body.model, result.promptSuggestionMode, helperSettings.recapAfterSeconds);
         return c.json({
             sessionId: result.sessionId,
             processId: result.id,
             projectId: result.projectId,
             permissionMode: result.permissionMode,
             modeVersion: result.modeVersion,
+            recapAfterSeconds: result.recapAfterSeconds,
             serverTimestamp,
         });
     });
@@ -1837,7 +2259,7 @@ export function createSessionsRoutes(deps) {
         }
         const projectPath = await ensureDetachedProjectPath(executor);
         const { thinking, effort } = body.thinking
-            ? thinkingOptionToConfig(body.thinking)
+            ? thinkingOptionToConfig(body.thinking, body.showThinking)
             : { thinking: undefined, effort: undefined };
         const model = body.model && body.model !== "default" ? body.model : undefined;
         const serviceTier = normalizeOptionalServiceTier(body.serviceTier);
@@ -1851,6 +2273,7 @@ export function createSessionsRoutes(deps) {
             globalInstructions: getGlobalInstructions(),
             permissions: body.permissions,
             recapMode: helperSettings.recapMode,
+            recapAfterSeconds: helperSettings.recapAfterSeconds,
             promptSuggestionMode: helperSettings.promptSuggestionMode,
             helperSideModel: helperSettings.helperSideModel,
         });
@@ -1860,13 +2283,14 @@ export function createSessionsRoutes(deps) {
         if (isQueuedResponse(result)) {
             return c.json({ ...result, serverTimestamp: Date.now() }, 202);
         }
-        await persistLaunchMetadata(result.sessionId, body.provider, executor);
+        await persistLaunchMetadata(result.sessionId, body.provider, executor, undefined, body.model, result.promptSuggestionMode, helperSettings.recapAfterSeconds);
         return c.json({
             sessionId: result.sessionId,
             processId: result.id,
             projectId: result.projectId,
             permissionMode: result.permissionMode,
             modeVersion: result.modeVersion,
+            recapAfterSeconds: result.recapAfterSeconds,
             serverTimestamp: Date.now(),
         });
     });
@@ -1901,6 +2325,11 @@ export function createSessionsRoutes(deps) {
         if (helperSettings.error) {
             return c.json({ error: helperSettings.error }, 400);
         }
+        const parsedResumeMode = parseOptionalResumeMode(body.resumeMode);
+        if (parsedResumeMode.error) {
+            return c.json({ error: parsedResumeMode.error }, 400);
+        }
+        const resumeMode = parsedResumeMode.resumeMode ?? "full";
         const serverTimestamp = Date.now();
         const userMessage = {
             text: body.message,
@@ -1913,10 +2342,16 @@ export function createSessionsRoutes(deps) {
         };
         // Convert thinking option to SDK config
         const { thinking, effort } = body.thinking
-            ? thinkingOptionToConfig(body.thinking)
+            ? thinkingOptionToConfig(body.thinking, body.showThinking)
             : { thinking: undefined, effort: undefined };
-        // Convert model option (undefined or "default" means use CLI default)
-        const model = body.model && body.model !== "default" ? body.model : undefined;
+        // Convert model option (undefined or "default" means use CLI default). When
+        // the client sends no model (e.g. resume after a server restart), recover the
+        // YA model id persisted at launch so the process keeps its requested alias
+        // and per-model settings stay keyed by it. See topics/provider-abstraction.md.
+        const requestedModel = body.model ?? deps.sessionMetadataService?.getRequestedModel(sessionId);
+        const model = requestedModel && requestedModel !== "default"
+            ? requestedModel
+            : undefined;
         const serviceTier = normalizeOptionalServiceTier(body.serviceTier);
         // Use client-provided executor, falling back to saved executor from metadata.
         let executor = parsedBodyExecutor.executor;
@@ -1945,23 +2380,14 @@ export function createSessionsRoutes(deps) {
                 await deps.sessionMetadataService.setExecutor(sessionId, executor);
             }
         }
-        const globalInstructions = deps.serverSettingsService?.getSetting("globalInstructions") || undefined;
+        const globalInstructions = getGlobalInstructions();
         // Look up the session's original provider so we resume with the correct one
         // (e.g., claude-ollama sessions need the Ollama provider, not default Claude).
         // Check metadata first (explicitly saved on creation), then fall back to reader.
         const metadataProvider = deps.sessionMetadataService?.getProvider(sessionId);
         let providerName = metadataProvider ?? body.provider;
         if (!providerName) {
-            const sessionSummaryResult = await findSessionSummaryAcrossProviders(project, sessionId, projectId, {
-                readerFactory: deps.readerFactory,
-                codexSessionsDir: deps.codexSessionsDir,
-                codexReaderFactory: deps.codexReaderFactory,
-                geminiSessionsDir: deps.geminiSessionsDir,
-                geminiReaderFactory: deps.geminiReaderFactory,
-                geminiHashToCwd: deps.geminiScanner?.getHashToCwd(),
-                grokSessionsDir: deps.grokSessionsDir,
-                grokReaderFactory: deps.grokReaderFactory,
-            }, metadataProvider ?? body.provider);
+            const sessionSummaryResult = await findSessionSummaryAcrossProviders(project, sessionId, projectId, providerResolutionDeps(deps), metadataProvider ?? body.provider, { readMode: "head" });
             const sessionSummary = sessionSummaryResult?.summary ?? null;
             providerName =
                 sessionSummary?.provider ??
@@ -1969,6 +2395,20 @@ export function createSessionsRoutes(deps) {
                     body.provider ??
                     project.provider;
         }
+        const previousProcess = deps.supervisor.getProcessForSession?.(sessionId);
+        const resumeDiagnostics = {
+            requestedMode: resumeMode,
+            provider: providerName,
+            previousProcess: previousProcess
+                ? {
+                    processId: previousProcess.id,
+                    state: previousProcess.state.type,
+                    provider: previousProcess.provider,
+                    supportsDynamicCommands: previousProcess.supportsDynamicCommands,
+                }
+                : null,
+        };
+        let resumeSessionAt;
         if (isClaudeSdkProviderName(providerName)) {
             let blocker = null;
             try {
@@ -1983,7 +2423,21 @@ export function createSessionsRoutes(deps) {
                     error: error instanceof Error ? error.message : String(error),
                 }, "Failed to check Claude session for resume-blocking API error");
             }
-            if (blocker) {
+            if (blocker?.resumeAtMessageId) {
+                // Recoverable: resume up to the last good assistant message,
+                // dropping the API-error tail, instead of forcing a handoff.
+                resumeSessionAt = blocker.resumeAtMessageId;
+                getLogger().info({
+                    event: "claude_resume_truncated_after_api_error",
+                    sessionId,
+                    projectId,
+                    providerName,
+                    messageId: blocker.messageId,
+                    apiErrorStatus: blocker.apiErrorStatus,
+                    resumeSessionAt,
+                }, "Resuming Claude session before SDK API-error tail");
+            }
+            else if (blocker) {
                 getLogger().warn({
                     event: "claude_resume_blocked_after_api_error",
                     sessionId,
@@ -1995,36 +2449,243 @@ export function createSessionsRoutes(deps) {
                 return c.json({
                     error: blocker.error,
                     recovery: blocker.recovery,
+                    resume: {
+                        ...resumeDiagnostics,
+                        blockedReason: "claude-api-error-tail",
+                    },
                 }, 409);
             }
         }
-        const result = await deps.supervisor.resumeSession(sessionId, project.path, userMessage, body.mode, {
-            model,
-            serviceTier,
-            thinking,
-            effort,
-            providerName,
-            executor,
-            globalInstructions,
-            permissions: body.permissions,
-            recapMode: helperSettings.recapMode,
-            promptSuggestionMode: helperSettings.promptSuggestionMode,
-            helperSideModel: helperSettings.helperSideModel,
-        });
+        let result;
+        try {
+            result = await deps.supervisor.resumeSession(sessionId, project.path, userMessage, body.mode, {
+                model,
+                serviceTier,
+                thinking,
+                effort,
+                providerName,
+                executor,
+                globalInstructions,
+                permissions: body.permissions,
+                recapMode: helperSettings.recapMode,
+                recapAfterSeconds: helperSettings.recapAfterSeconds ??
+                    deps.sessionMetadataService?.getRecapAfterSeconds?.(sessionId),
+                // Body value wins; otherwise recover the per-session preference from
+                // metadata so a body-less resume does not default back to native.
+                promptSuggestionMode: helperSettings.promptSuggestionMode ??
+                    deps.sessionMetadataService?.getPromptSuggestionMode?.(sessionId),
+                helperSideModel: helperSettings.helperSideModel,
+                resumeMode,
+                resumeSessionAt,
+            });
+        }
+        catch (error) {
+            if (error instanceof ResumeCompactionError) {
+                getLogger().warn({
+                    event: "resume_compaction_failed",
+                    sessionId,
+                    projectId,
+                    providerName,
+                    attempt: error.attempt,
+                }, "Compact-first resume failed");
+                return c.json({
+                    error: error.message,
+                    recovery: error.recovery,
+                    resume: {
+                        ...resumeDiagnostics,
+                        compaction: error.attempt,
+                    },
+                }, 409);
+            }
+            throw error;
+        }
         // Check if queue is full
         if (isQueueFullResponse(result)) {
             return c.json({ error: "Queue is full", maxQueueSize: result.maxQueueSize }, 503);
         }
         // Check if request was queued
         if (isQueuedResponse(result)) {
-            return c.json({ ...result, serverTimestamp: Date.now() }, 202); // 202 Accepted - queued for processing
+            return c.json({
+                ...result,
+                serverTimestamp: Date.now(),
+                resume: { ...resumeDiagnostics, outcome: "queued" },
+            }, 202); // 202 Accepted - queued for processing
         }
         return c.json({
             processId: result.id,
             permissionMode: result.permissionMode,
             modeVersion: result.modeVersion,
+            recapAfterSeconds: result.recapAfterSeconds,
             serverTimestamp,
+            resume: {
+                ...resumeDiagnostics,
+                outcome: "started",
+                compaction: resumeMode === "compact-first" ? { status: "completed" } : undefined,
+            },
+        });
+    });
+    // POST /api/projects/:projectId/sessions/:sessionId/reactivate
+    // Spawn a live harness process bound to the session WITHOUT delivering a turn,
+    // so the client can read live process state (model options) before messaging.
+    // Idempotent: returns the existing process if the session is already owned.
+    routes.post("/projects/:projectId/sessions/:sessionId/reactivate", async (c) => {
+        const projectId = c.req.param("projectId");
+        const sessionId = c.req.param("sessionId");
+        if (!isUrlProjectId(projectId)) {
+            return c.json({ error: "Invalid project ID format" }, 400);
+        }
+        const project = await deps.scanner.getOrCreateProject(projectId);
+        if (!project) {
+            return c.json({ error: "Project not found or path does not exist" }, 404);
+        }
+        // Already owned by a live process - return it (idempotent).
+        const existing = deps.supervisor.getProcessForSession(sessionId);
+        if (existing) {
+            return c.json({
+                processId: existing.id,
+                permissionMode: existing.permissionMode,
+                modeVersion: existing.modeVersion,
+                recapAfterSeconds: existing.recapAfterSeconds,
+                serverTimestamp: Date.now(),
+            });
+        }
+        // Body is optional - allows overriding mode/model/executor.
+        let body = {};
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            // No body - resume with the session's saved settings.
+        }
+        const parsedBodyExecutor = parseOptionalExecutor(body.executor);
+        if (parsedBodyExecutor.error) {
+            return c.json({ error: parsedBodyExecutor.error }, 400);
+        }
+        const helperSettings = parseHelperSettings(body);
+        if (helperSettings.error) {
+            return c.json({ error: helperSettings.error }, 400);
+        }
+        // Resolve provider/model/executor from the YA launch record (persisted on
+        // launch) so reactivation resumes with the correct backend and model.
+        const metadata = deps.sessionMetadataService?.getMetadata(sessionId);
+        const providerName = metadata?.provider ??
+            body.provider ??
+            project.provider;
+        const executor = parsedBodyExecutor.executor ?? metadata?.executor;
+        // Prefer an explicit override, else the YA id the session was launched
+        // with; "default" means let the backend pick (pass undefined).
+        const rawModel = body.model && body.model !== "default"
+            ? body.model
+            : metadata?.requestedModel;
+        const model = rawModel && rawModel !== "default" ? rawModel : undefined;
+        const { thinking, effort } = body.thinking
+            ? thinkingOptionToConfig(body.thinking, body.showThinking)
+            : { thinking: undefined, effort: undefined };
+        let process;
+        try {
+            process = await deps.supervisor.reactivateSession(project.path, sessionId, body.mode, {
+                model,
+                thinking,
+                effort,
+                providerName,
+                executor,
+                globalInstructions: getGlobalInstructions(),
+                recapAfterSeconds: helperSettings.recapAfterSeconds ?? metadata?.recapAfterSeconds,
+                recapMode: helperSettings.recapMode ?? metadata?.recapMode,
+            });
+        }
+        catch (error) {
+            return c.json({
+                error: error instanceof Error
+                    ? error.message
+                    : "Failed to reactivate session",
+            }, 503);
+        }
+        // Keep the launch record current (provider/executor) for this session.
+        await persistLaunchMetadata(sessionId, providerName, executor);
+        return c.json({
+            processId: process.id,
+            permissionMode: process.permissionMode,
+            modeVersion: process.modeVersion,
+            recapAfterSeconds: process.recapAfterSeconds,
+            serverTimestamp: Date.now(),
+        });
+    });
+    // POST /api/projects/:projectId/sessions/:sessionId/recap
+    // Away-recap trigger, keyed by session (not process) so it survives a server
+    // restart that killed the process. A live process recaps directly in its own
+    // mode; a cold fork-mode session is revived — without ever preempting a live
+    // worker — and recapped from its on-disk transcript. See topics/fork-recap.md.
+    routes.post("/projects/:projectId/sessions/:sessionId/recap", async (c) => {
+        const projectId = c.req.param("projectId");
+        const sessionId = c.req.param("sessionId");
+        if (!isUrlProjectId(projectId)) {
+            return c.json({ error: "Invalid project ID format" }, 400);
+        }
+        let sinceMs = null;
+        try {
+            const body = await c.req.json();
+            if (typeof body.hiddenSinceMs === "number" &&
+                Number.isFinite(body.hiddenSinceMs)) {
+                sinceMs = body.hiddenSinceMs;
+            }
+        }
+        catch {
+            // Empty body is accepted.
+        }
+        // Live process: recap directly in whatever mode it runs.
+        const live = deps.supervisor.getProcessForSession(sessionId);
+        if (live && !live.isTerminated) {
+            const result = await deps.supervisor.requestRecap(live.id, { sinceMs });
+            return c.json(result);
+        }
+        // Cold session: only fork mode can recap from the on-disk transcript —
+        // side-session/native recaps need in-memory recent text a revived process
+        // lacks. Other modes simply skip until the session is live again.
+        const recapMode = deps.sessionMetadataService?.getRecapMode(sessionId);
+        if (recapMode !== "fork") {
+            return c.json({
+                supported: true,
+                emitted: false,
+                reason: "recap requires a live process for this recap mode",
+            });
+        }
+        const project = await deps.scanner.getOrCreateProject(projectId);
+        if (!project) {
+            return c.json({ error: "Project not found or path does not exist" }, 404);
+        }
+        const metadata = deps.sessionMetadataService?.getMetadata(sessionId);
+        const providerName = metadata?.provider ?? project.provider;
+        const rawModel = metadata?.requestedModel;
+        const model = rawModel && rawModel !== "default" ? rawModel : undefined;
+        let process;
+        try {
+            process = await deps.supervisor.reactivateSession(project.path, sessionId, undefined, {
+                model,
+                providerName,
+                executor: metadata?.executor,
+                globalInstructions: getGlobalInstructions(),
+                recapAfterSeconds: metadata?.recapAfterSeconds,
+                recapMode: "fork",
+            }, { preempt: false });
+        }
+        catch (error) {
+            // At capacity with no idle worker to drop (background recaps never
+            // preempt), or reactivation failed — skip the recap rather than error.
+            const atCapacity = error instanceof Error && error.message.includes("worker capacity");
+            return c.json({
+                supported: true,
+                emitted: false,
+                reason: atCapacity
+                    ? "recap skipped: at worker capacity"
+                    : "recap skipped: session could not be revived",
+            });
+        }
+        const result = await deps.supervisor.requestRecap(process.id, {
+            sinceMs,
+            revived: true,
         });
+        return c.json(result);
     });
     // POST /api/projects/:projectId/sessions/:sessionId/restart
     // Start a fresh session from a bounded handoff, then terminate the old YA-owned process.
@@ -2061,10 +2722,18 @@ export function createSessionsRoutes(deps) {
             }
             executor = parsedSavedExecutor.executor;
         }
+        if (body.restartMode !== undefined &&
+            body.restartMode !== "handoff" &&
+            body.restartMode !== "fork") {
+            return c.json({ error: 'restartMode must be "handoff" or "fork"' }, 400);
+        }
+        const restartMode = body.restartMode ?? "handoff";
         const oldProcess = deps.supervisor.getProcessForSession(sessionId);
         const metadataProvider = deps.sessionMetadataService?.getProvider(sessionId);
         const preferredSourceProvider = metadataProvider ?? oldProcess?.provider ?? project.provider;
-        const compactAttempt = await tryRestartCompact(oldProcess);
+        // Fork copies the transcript as-is; pre-restart compaction is a
+        // handoff-only mitigation.
+        const compactAttempt = restartMode === "fork" ? undefined : await tryRestartCompact(oldProcess);
         const oldProcessInterrupted = await interruptOldProcessForHandoff(oldProcess);
         const sourceSession = await loadRestartSourceSession(project, sessionId, projectId, preferredSourceProvider, oldProcess);
         if (!sourceSession) {
@@ -2073,6 +2742,105 @@ export function createSessionsRoutes(deps) {
         const sourceProvider = sourceSession.provider ?? preferredSourceProvider;
         const providerName = body.provider ?? sourceProvider;
         const originalMetadata = deps.sessionMetadataService?.getMetadata(sessionId);
+        const { thinking, effort } = body.thinking
+            ? thinkingOptionToConfig(body.thinking, body.showThinking)
+            : { thinking: undefined, effort: undefined };
+        const model = body.model && body.model !== "default" ? body.model : undefined;
+        const serviceTier = normalizeOptionalServiceTier(body.serviceTier);
+        if (restartMode === "fork") {
+            if (body.provider && body.provider !== sourceProvider) {
+                return c.json({
+                    error: "Fork keeps the source provider; omit provider or match the source session",
+                }, 400);
+            }
+            if (!deps.supervisor.supportsForkSession(sourceProvider)) {
+                return c.json({ error: `${sourceProvider} does not support transcript fork` }, 400);
+            }
+            const forkTitle = deriveForkTitle({
+                preferredTitle: originalMetadata?.customTitle,
+                sourceSession,
+            });
+            let fork;
+            try {
+                fork = await deps.supervisor.forkSession({
+                    sessionId,
+                    projectPath: project.path,
+                    providerName: sourceProvider,
+                    upToMessageId: body.forkUpToMessageId,
+                    title: forkTitle,
+                });
+            }
+            catch (error) {
+                getLogger().warn({
+                    event: "restart_fork_failed",
+                    sessionId,
+                    projectId,
+                    sourceProvider,
+                    upToMessageId: body.forkUpToMessageId,
+                    error: error instanceof Error ? error.message : String(error),
+                }, "Transcript fork failed");
+                return c.json({
+                    error: error instanceof Error ? error.message : "Transcript fork failed",
+                }, 500);
+            }
+            const forkMessage = body.reason?.trim() || "Continue from this fork point.";
+            const result = await deps.supervisor.resumeSession(fork.sessionId, project.path, { text: forkMessage, mode: body.mode }, body.mode, {
+                model,
+                serviceTier,
+                thinking,
+                effort,
+                providerName: sourceProvider,
+                executor,
+                globalInstructions: getGlobalInstructions(),
+                permissions: body.permissions,
+                recapMode: helperSettings.recapMode,
+                recapAfterSeconds: helperSettings.recapAfterSeconds ??
+                    originalMetadata?.recapAfterSeconds,
+                // Inherit the source session's preference unless the body overrides.
+                promptSuggestionMode: helperSettings.promptSuggestionMode ??
+                    originalMetadata?.promptSuggestionMode,
+                helperSideModel: helperSettings.helperSideModel,
+            });
+            if (isQueueFullResponse(result)) {
+                return c.json({ error: "Queue is full", maxQueueSize: result.maxQueueSize }, 503);
+            }
+            if (isQueuedResponse(result)) {
+                deps.supervisor.cancelQueuedRequest(result.queueId);
+                return c.json({
+                    error: "Fork could not start immediately; old process was left running",
+                }, 503);
+            }
+            await persistLaunchMetadata(result.sessionId, sourceProvider, executor, undefined, body.model ?? deps.sessionMetadataService?.getRequestedModel(sessionId), result.promptSuggestionMode, result.recapAfterSeconds);
+            if (deps.sessionMetadataService) {
+                await deps.sessionMetadataService.updateMetadata(result.sessionId, {
+                    title: forkTitle,
+                });
+                deps.eventBus?.emit({
+                    type: "session-metadata-changed",
+                    sessionId: result.sessionId,
+                    title: forkTitle,
+                    timestamp: new Date().toISOString(),
+                });
+            }
+            const oldProcessAbortDeferred = abortOldProcessAfterReplacementActivity(oldProcess, result);
+            return c.json({
+                sessionId: result.sessionId,
+                processId: result.id,
+                projectId: result.projectId,
+                provider: result.provider,
+                model: result.resolvedModel ?? result.model,
+                title: forkTitle,
+                permissionMode: result.permissionMode,
+                modeVersion: result.modeVersion,
+                recapAfterSeconds: result.recapAfterSeconds,
+                restartedFrom: sessionId,
+                forkUpToMessageId: body.forkUpToMessageId,
+                oldProcessId: oldProcess?.id,
+                oldProcessInterrupted,
+                oldProcessAbortDeferred,
+                oldProcessAborted: false,
+            });
+        }
         const handoffTitle = deriveRestartTitle({
             preferredTitle: originalMetadata?.customTitle,
             sourceSession,
@@ -2090,11 +2858,6 @@ export function createSessionsRoutes(deps) {
             omittedCount,
             transcript,
         });
-        const { thinking, effort } = body.thinking
-            ? thinkingOptionToConfig(body.thinking)
-            : { thinking: undefined, effort: undefined };
-        const model = body.model && body.model !== "default" ? body.model : undefined;
-        const serviceTier = normalizeOptionalServiceTier(body.serviceTier);
         const result = await deps.supervisor.startSession(project.path, {
             text: handoff,
             mode: body.mode,
@@ -2109,7 +2872,11 @@ export function createSessionsRoutes(deps) {
             globalInstructions: getGlobalInstructions(),
             permissions: body.permissions,
             recapMode: helperSettings.recapMode,
-            promptSuggestionMode: helperSettings.promptSuggestionMode,
+            recapAfterSeconds: helperSettings.recapAfterSeconds ??
+                originalMetadata?.recapAfterSeconds,
+            // Inherit the source session's preference unless the body overrides.
+            promptSuggestionMode: helperSettings.promptSuggestionMode ??
+                originalMetadata?.promptSuggestionMode,
             helperSideModel: helperSettings.helperSideModel,
         });
         if (isQueueFullResponse(result)) {
@@ -2121,7 +2888,7 @@ export function createSessionsRoutes(deps) {
                 error: "Restart could not start immediately; old process was left running",
             }, 503);
         }
-        await persistLaunchMetadata(result.sessionId, providerName, executor);
+        await persistLaunchMetadata(result.sessionId, providerName, executor, undefined, body.model ?? deps.sessionMetadataService?.getRequestedModel(sessionId), result.promptSuggestionMode, result.recapAfterSeconds);
         if (deps.sessionMetadataService) {
             await deps.sessionMetadataService.updateMetadata(result.sessionId, {
                 title: handoffTitle,
@@ -2143,6 +2910,7 @@ export function createSessionsRoutes(deps) {
             title: handoffTitle,
             permissionMode: result.permissionMode,
             modeVersion: result.modeVersion,
+            recapAfterSeconds: result.recapAfterSeconds,
             restartedFrom: sessionId,
             oldProcessId: oldProcess?.id,
             oldProcessInterrupted,
@@ -2150,43 +2918,617 @@ export function createSessionsRoutes(deps) {
             oldProcessAborted: false,
         });
     });
-    // POST /api/sessions/:sessionId/messages - Queue message
-    routes.post("/sessions/:sessionId/messages", async (c) => {
+    // POST /api/projects/:projectId/sessions/:sessionId/fork
+    // Fork the provider transcript into a new resumable session without
+    // starting a process or sending any message ("fork from here" / rewind).
+    // The forked session opens cold; the next user send resumes it normally.
+    routes.post("/projects/:projectId/sessions/:sessionId/fork", async (c) => {
+        const projectId = c.req.param("projectId");
         const sessionId = c.req.param("sessionId");
-        const process = deps.supervisor.getProcessForSession(sessionId);
-        if (!process) {
-            return c.json({ error: "No active process for session" }, 404);
+        if (!isUrlProjectId(projectId)) {
+            return c.json({ error: "Invalid project ID format" }, 400);
         }
-        let body;
+        const project = await deps.scanner.getOrCreateProject(projectId);
+        if (!project) {
+            return c.json({ error: "Project not found or path does not exist" }, 404);
+        }
+        let body = {};
         try {
             body = await c.req.json();
         }
         catch {
-            return c.json({ error: "Invalid JSON body" }, 400);
+            // Body is optional; full-transcript fork.
         }
-        if (!body.message) {
-            return c.json({ error: "Message is required" }, 400);
+        const upToMessageId = typeof body.upToMessageId === "string" && body.upToMessageId
+            ? body.upToMessageId
+            : undefined;
+        const metadataProvider = deps.sessionMetadataService?.getProvider(sessionId);
+        const sourceProcess = deps.supervisor.getProcessForSession(sessionId);
+        const sessionSummaryResult = await findSessionSummaryAcrossProviders(project, sessionId, projectId, providerResolutionDeps(deps), sourceProcess?.provider ?? metadataProvider, { readMode: "head" });
+        const sessionSummary = sessionSummaryResult?.summary ?? null;
+        const providerName = sourceProcess?.provider ??
+            metadataProvider ??
+            sessionSummary?.provider ??
+            project.provider;
+        if (!deps.supervisor.supportsForkSession(providerName)) {
+            return c.json({ error: `${providerName} does not support transcript fork` }, 400);
         }
-        const serverTimestamp = Date.now();
-        const userMessage = {
-            text: body.message,
-            images: body.images,
-            documents: body.documents,
-            attachments: body.attachments,
-            mode: body.mode,
-            tempId: body.tempId,
-            metadata: buildUserMessageMetadata(body, serverTimestamp, body.deferred ? "deferred" : "direct"),
-        };
-        // Check if process is terminated
-        if (process.isTerminated) {
+        const originalMetadata = deps.sessionMetadataService?.getMetadata(sessionId);
+        let baseTitle = normalizeRestartTitleCandidate(originalMetadata?.customTitle);
+        if (!baseTitle) {
+            try {
+                const summary = await deps
+                    .readerFactory(project)
+                    .getSessionSummary(sessionId, projectId, { readMode: "head" });
+                baseTitle = normalizeRestartTitleCandidate(summary?.title);
+            }
+            catch {
+                // Title is cosmetic; fall through to the provider default.
+            }
+        }
+        const forkTitle = baseTitle
+            ? truncateSessionTitle(/^Fork:/i.test(baseTitle) ? baseTitle : `Fork: ${baseTitle}`)
+            : undefined;
+        let fork;
+        try {
+            fork = await deps.supervisor.forkSession({
+                sessionId,
+                projectPath: project.path,
+                providerName,
+                upToMessageId,
+                title: forkTitle,
+            });
+        }
+        catch (error) {
+            getLogger().warn({
+                event: "session_fork_failed",
+                sessionId,
+                projectId,
+                providerName,
+                upToMessageId,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Transcript fork failed");
             return c.json({
-                error: "Process terminated",
-                reason: process.terminationReason,
-            }, 410); // 410 Gone
+                error: error instanceof Error ? error.message : "Transcript fork failed",
+            }, 500);
         }
-        const resolvedModel = body.model && body.model !== "default"
-            ? body.model
-            : process.resolvedModel ?? process.model;
+        const savedExecutor = parseOptionalExecutor(deps.sessionMetadataService?.getExecutor(sessionId)).executor;
+        await persistLaunchMetadata(fork.sessionId, providerName, savedExecutor, undefined, deps.sessionMetadataService?.getRequestedModel(sessionId), originalMetadata?.promptSuggestionMode, originalMetadata?.recapAfterSeconds);
+        if (deps.sessionMetadataService) {
+            await deps.sessionMetadataService.updateMetadata(fork.sessionId, {
+                title: forkTitle,
+                parentSessionId: sessionId,
+            });
+            deps.eventBus?.emit({
+                type: "session-metadata-changed",
+                sessionId: fork.sessionId,
+                title: forkTitle,
+                parentSessionId: sessionId,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        return c.json({
+            sessionId: fork.sessionId,
+            projectId,
+            provider: providerName,
+            title: forkTitle,
+            forkedFrom: sessionId,
+            upToMessageId,
+        });
+    });
+    // POST /api/projects/:projectId/sessions/:sessionId/retitle
+    // Generate a proposed session title through an archived helper fork. This
+    // never updates the source session title; the client must explicitly accept
+    // the returned proposal through the ordinary metadata update route.
+    routes.post("/projects/:projectId/sessions/:sessionId/retitle", async (c) => {
+        const projectId = c.req.param("projectId");
+        const sessionId = c.req.param("sessionId");
+        if (!isUrlProjectId(projectId)) {
+            return c.json({ error: "Invalid project ID format" }, 400);
+        }
+        const project = await deps.scanner.getOrCreateProject(projectId);
+        if (!project) {
+            return c.json({ error: "Project not found or path does not exist" }, 404);
+        }
+        if (!deps.sessionMetadataService) {
+            return c.json({ error: "Session metadata service not available" }, 503);
+        }
+        let body = {};
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            // Body is optional.
+        }
+        const currentTitle = typeof body.currentTitle === "string"
+            ? body.currentTitle.trim().slice(0, 200)
+            : undefined;
+        let lengthTarget;
+        if (body.lengthTarget !== undefined) {
+            if (typeof body.lengthTarget !== "number" ||
+                !Number.isInteger(body.lengthTarget) ||
+                body.lengthTarget < 20 ||
+                body.lengthTarget > 132) {
+                return c.json({ error: "lengthTarget must be an integer between 20 and 132" }, 400);
+            }
+            lengthTarget = body.lengthTarget;
+        }
+        const metadataProvider = deps.sessionMetadataService.getProvider(sessionId);
+        let sourceProcess = deps.supervisor.getProcessForSession(sessionId);
+        const liveSourceProcess = sourceProcess && !sourceProcess.isTerminated ? sourceProcess : undefined;
+        const sessionSummaryResult = await findSessionSummaryAcrossProviders(project, sessionId, projectId, providerResolutionDeps(deps), liveSourceProcess?.provider ?? metadataProvider, { readMode: "head" });
+        const sessionSummary = sessionSummaryResult?.summary ?? null;
+        const providerName = liveSourceProcess?.provider ??
+            metadataProvider ??
+            sessionSummary?.provider ??
+            sourceProcess?.provider ??
+            project.provider;
+        if (!deps.supervisor.supportsForkSession(providerName)) {
+            return c.json({ error: `${providerName} does not support transcript fork` }, 400);
+        }
+        const savedExecutor = parseOptionalExecutor(deps.sessionMetadataService.getExecutor(sessionId)).executor;
+        let requestedModel = deps.sessionMetadataService.getRequestedModel(sessionId) ??
+            liveSourceProcess?.model;
+        const sourceMetadata = deps.sessionMetadataService.getMetadata(sessionId);
+        const promptSuggestionMode = sourceMetadata?.promptSuggestionMode;
+        const recapAfterSeconds = sourceMetadata?.recapAfterSeconds;
+        const abortController = new AbortController();
+        const abortFromRequest = () => abortController.abort();
+        if (c.req.raw.signal.aborted) {
+            abortController.abort();
+        }
+        else {
+            c.req.raw.signal.addEventListener("abort", abortFromRequest, {
+                once: true,
+            });
+        }
+        let generatorSessionId;
+        try {
+            if (!liveSourceProcess) {
+                sourceProcess = await deps.supervisor.reactivateSession(project.path, sessionId, undefined, {
+                    model: requestedModel && requestedModel !== "default"
+                        ? requestedModel
+                        : undefined,
+                    providerName,
+                    executor: savedExecutor,
+                    globalInstructions: getGlobalInstructions(),
+                    promptSuggestionMode,
+                    recapAfterSeconds,
+                });
+                requestedModel = requestedModel ?? sourceProcess.model;
+            }
+            const generator = await deps.supervisor.forkSession({
+                sessionId,
+                projectPath: project.path,
+                providerName,
+                title: "Retitle generator",
+            });
+            generatorSessionId = generator.sessionId;
+            await updateForkSummaryChildMetadata(generator.sessionId, sessionId, "Retitle generator", true);
+            await persistLaunchMetadata(generator.sessionId, providerName, savedExecutor, undefined, requestedModel, promptSuggestionMode, recapAfterSeconds);
+            if (abortController.signal.aborted) {
+                throw new DOMException("Retitle cancelled", "AbortError");
+            }
+            const generated = await deps.supervisor.generateSummary(providerName, {
+                purpose: "session-retitle",
+                strategy: "fork",
+                generatorSessionId: generator.sessionId,
+                cwd: project.path,
+                currentTitle,
+                lengthTarget,
+                signal: abortController.signal,
+            });
+            const title = generatedRetitleCandidate(generated.text);
+            if (!title) {
+                throw new Error("Retitle generation returned empty title");
+            }
+            return c.json({ title, generatorSessionId: generator.sessionId });
+        }
+        catch (error) {
+            const cancelled = abortController.signal.aborted ||
+                (error instanceof DOMException && error.name === "AbortError");
+            const message = error instanceof Error ? error.message : "Retitle generation failed";
+            getLogger().warn({
+                event: cancelled
+                    ? "session_retitle_cancelled"
+                    : "session_retitle_failed",
+                sessionId,
+                projectId,
+                providerName,
+                generatorSessionId,
+                error: message,
+            }, cancelled ? "Session retitle cancelled" : "Session retitle failed");
+            return c.json({ error: message }, cancelled ? 400 : 500);
+        }
+        finally {
+            c.req.raw.signal.removeEventListener("abort", abortFromRequest);
+            abortController.abort();
+        }
+    });
+    // POST /api/projects/:projectId/sessions/:sessionId/fork-summary
+    // Start a server-owned whole-context fork-after-summary job. The response
+    // returns after durable job creation; generation continues independently of
+    // the requesting client connection.
+    routes.post("/projects/:projectId/sessions/:sessionId/fork-summary", async (c) => {
+        const projectId = c.req.param("projectId");
+        const sessionId = c.req.param("sessionId");
+        if (!isUrlProjectId(projectId)) {
+            return c.json({ error: "Invalid project ID format" }, 400);
+        }
+        const project = await deps.scanner.getOrCreateProject(projectId);
+        if (!project) {
+            return c.json({ error: "Project not found or path does not exist" }, 404);
+        }
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: "Invalid JSON body" }, 400);
+        }
+        const sourceMessageId = typeof body.sourceMessageId === "string" && body.sourceMessageId.trim()
+            ? body.sourceMessageId.trim()
+            : undefined;
+        if (!sourceMessageId) {
+            return c.json({ error: "sourceMessageId is required" }, 400);
+        }
+        if (body.mode !== undefined &&
+            (typeof body.mode !== "string" ||
+                !ALL_PERMISSION_MODES.includes(body.mode))) {
+            return c.json({ error: "Invalid permission mode" }, 400);
+        }
+        if (body.autoOpenWhenReady !== undefined &&
+            typeof body.autoOpenWhenReady !== "boolean") {
+            return c.json({ error: "autoOpenWhenReady must be a boolean" }, 400);
+        }
+        const mode = body.mode;
+        const instructions = typeof body.instructions === "string" ? body.instructions : undefined;
+        const autoOpenWhenReady = body.autoOpenWhenReady === true;
+        const metadataProvider = deps.sessionMetadataService?.getProvider(sessionId);
+        const sourceProcess = deps.supervisor.getProcessForSession(sessionId);
+        const providerName = metadataProvider ?? sourceProcess?.provider ?? project.provider;
+        if (!deps.supervisor.supportsForkSession(providerName)) {
+            return c.json({ error: `${providerName} does not support transcript fork` }, 400);
+        }
+        if (!deps.sessionMetadataService) {
+            return c.json({ error: "Session metadata service not available" }, 503);
+        }
+        if (activeForkSummaryJobs.has(sessionId)) {
+            return c.json({ error: "A fork summary is already generating for this session" }, 409);
+        }
+        const sourceSession = sourceProcess
+            ? {
+                messages: sdkMessagesToClientMessages(sourceProcess.getMessageHistory()),
+            }
+            : await loadRestartSourceSession(project, sessionId, projectId, providerName);
+        if (!sourceSession) {
+            return c.json({ error: "Source session not found" }, 404);
+        }
+        const boundary = resolveForkAfterBoundary(sourceSession.messages, sourceMessageId, sourceProcess?.state.type === "in-turn" ||
+            sourceProcess?.state.type === "waiting-input");
+        if ("error" in boundary) {
+            return c.json({ error: boundary.error }, boundary.status);
+        }
+        const displayObject = {
+            id: randomUUID(),
+            kind: "fork-summary",
+            createdAt: new Date().toISOString(),
+            placementAfterMessageId: boundary.placementAfterMessageId,
+            sourceMessageId,
+            retainedThroughMessageId: boundary.retainedThroughMessageId,
+            status: "generating",
+            autoOpenWhenReady: autoOpenWhenReady || undefined,
+        };
+        const abortController = new AbortController();
+        activeForkSummaryJobs.set(sessionId, {
+            objectId: displayObject.id,
+            abortController,
+        });
+        try {
+            await deps.sessionMetadataService.addTranscriptDisplayObject(sessionId, displayObject);
+        }
+        catch (error) {
+            activeForkSummaryJobs.delete(sessionId);
+            throw error;
+        }
+        emitTranscriptDisplayObjects(sessionId);
+        const originalMetadata = deps.sessionMetadataService.getMetadata(sessionId);
+        const baseTitle = normalizeRestartTitleCandidate(originalMetadata?.customTitle ?? sourceSession.title);
+        const fallbackTitle = baseTitle
+            ? truncateSessionTitle(/^Fork:/i.test(baseTitle) ? baseTitle : `Fork: ${baseTitle}`)
+            : undefined;
+        const savedExecutor = parseOptionalExecutor(deps.sessionMetadataService.getExecutor(sessionId)).executor;
+        const requestedModel = deps.sessionMetadataService.getRequestedModel(sessionId) ??
+            sourceProcess?.model;
+        void (async () => {
+            let generatorSessionId;
+            let targetSessionId;
+            let targetTitle;
+            let targetProcessId;
+            let completed = false;
+            try {
+                const generator = await deps.supervisor.forkSession({
+                    sessionId,
+                    projectPath: project.path,
+                    providerName,
+                    title: "Fork summary generator",
+                });
+                generatorSessionId = generator.sessionId;
+                await updateForkSummaryChildMetadata(generator.sessionId, sessionId, "Fork summary generator", true);
+                await persistLaunchMetadata(generator.sessionId, providerName, savedExecutor, undefined, requestedModel, originalMetadata?.promptSuggestionMode, originalMetadata?.recapAfterSeconds);
+                if (abortController.signal.aborted) {
+                    throw new DOMException("Fork summary cancelled", "AbortError");
+                }
+                const generated = await deps.supervisor.generateSummary(providerName, {
+                    purpose: "fork-after-summary",
+                    strategy: "fork",
+                    generatorSessionId: generator.sessionId,
+                    cwd: project.path,
+                    afterTurnMessageId: boundary.retainedThroughMessageId,
+                    afterTurnContext: boundary.retainedThroughContext,
+                    instructions,
+                    signal: abortController.signal,
+                });
+                if (abortController.signal.aborted) {
+                    throw new DOMException("Fork summary cancelled", "AbortError");
+                }
+                const title = forkSummaryTitle(generated.text, fallbackTitle);
+                targetTitle = title;
+                const target = await deps.supervisor.forkSession({
+                    sessionId,
+                    projectPath: project.path,
+                    providerName,
+                    upToMessageId: boundary.retainedThroughMessageId,
+                    title,
+                });
+                targetSessionId = target.sessionId;
+                await updateForkSummaryChildMetadata(target.sessionId, sessionId, title, true);
+                await persistLaunchMetadata(target.sessionId, providerName, savedExecutor, undefined, requestedModel, originalMetadata?.promptSuggestionMode, originalMetadata?.recapAfterSeconds);
+                if (abortController.signal.aborted) {
+                    throw new DOMException("Fork summary cancelled", "AbortError");
+                }
+                const result = await deps.supervisor.resumeSession(target.sessionId, project.path, { text: generated.text, mode }, mode, {
+                    providerName,
+                    executor: savedExecutor,
+                    globalInstructions: getGlobalInstructions(),
+                    model: requestedModel,
+                    promptSuggestionMode: originalMetadata?.promptSuggestionMode,
+                    recapAfterSeconds: originalMetadata?.recapAfterSeconds,
+                });
+                if (isQueueFullResponse(result)) {
+                    throw new Error("Queue is full");
+                }
+                if (isQueuedResponse(result)) {
+                    deps.supervisor.cancelQueuedRequest(result.queueId);
+                    throw new Error("Fork summary could not start immediately");
+                }
+                targetProcessId = result.id;
+                if (abortController.signal.aborted) {
+                    await deps.supervisor.abortProcess(result.id);
+                    targetProcessId = undefined;
+                    throw new DOMException("Fork summary cancelled", "AbortError");
+                }
+                await persistLaunchMetadata(result.sessionId, providerName, savedExecutor, undefined, requestedModel, result.promptSuggestionMode, result.recapAfterSeconds);
+                await updateForkSummaryChildMetadata(result.sessionId, sessionId, title, false);
+                await deps.sessionMetadataService?.updateTranscriptDisplayObject(sessionId, displayObject.id, (object) => ({
+                    ...object,
+                    status: "ready",
+                    targetSessionId: result.sessionId,
+                    title,
+                    error: undefined,
+                }));
+                emitTranscriptDisplayObjects(sessionId);
+                completed = true;
+            }
+            catch (error) {
+                const cancelled = abortController.signal.aborted ||
+                    (error instanceof DOMException && error.name === "AbortError");
+                const logCleanupFailure = (stage, cleanupError) => {
+                    getLogger().warn({
+                        event: "fork_after_summary_cleanup_failed",
+                        sessionId,
+                        projectId,
+                        providerName,
+                        stage,
+                        error: cleanupError instanceof Error
+                            ? cleanupError.message
+                            : String(cleanupError),
+                    }, "Fork-after-summary cleanup failed");
+                };
+                if (generatorSessionId) {
+                    try {
+                        await updateForkSummaryChildMetadata(generatorSessionId, sessionId, "Fork summary generator", true);
+                    }
+                    catch (cleanupError) {
+                        logCleanupFailure("archive-generator", cleanupError);
+                    }
+                }
+                if (targetSessionId && targetTitle) {
+                    try {
+                        await updateForkSummaryChildMetadata(targetSessionId, sessionId, targetTitle, true);
+                    }
+                    catch (cleanupError) {
+                        logCleanupFailure("archive-target", cleanupError);
+                    }
+                }
+                if (!completed && targetProcessId) {
+                    try {
+                        await deps.supervisor.abortProcess(targetProcessId);
+                    }
+                    catch (cleanupError) {
+                        logCleanupFailure("abort-target-process", cleanupError);
+                    }
+                }
+                if (!cancelled) {
+                    const message = error instanceof Error
+                        ? error.message
+                        : "Summary generation failed";
+                    getLogger().warn({
+                        event: "fork_after_summary_failed",
+                        sessionId,
+                        projectId,
+                        providerName,
+                        sourceMessageId,
+                        error: message,
+                    }, "Fork-after-summary job failed");
+                    try {
+                        await deps.sessionMetadataService?.updateTranscriptDisplayObject(sessionId, displayObject.id, (object) => ({
+                            ...object,
+                            status: "error",
+                            error: message,
+                        }));
+                        emitTranscriptDisplayObjects(sessionId);
+                    }
+                    catch (cleanupError) {
+                        logCleanupFailure("persist-error-state", cleanupError);
+                    }
+                }
+            }
+            finally {
+                const active = activeForkSummaryJobs.get(sessionId);
+                if (active?.objectId === displayObject.id) {
+                    activeForkSummaryJobs.delete(sessionId);
+                }
+            }
+        })().catch((error) => {
+            getLogger().error({
+                event: "fork_after_summary_unhandled_failure",
+                sessionId,
+                projectId,
+                providerName,
+                sourceMessageId,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Fork-after-summary job escaped its guarded workflow");
+        });
+        return c.json({ displayObject }, 202);
+    });
+    routes.post("/projects/:projectId/sessions/:sessionId/fork-summary/:objectId/cancel", async (c) => {
+        const projectId = c.req.param("projectId");
+        const sessionId = c.req.param("sessionId");
+        const objectId = c.req.param("objectId");
+        if (!isUrlProjectId(projectId)) {
+            return c.json({ error: "Invalid project ID format" }, 400);
+        }
+        const active = activeForkSummaryJobs.get(sessionId);
+        const object = deps.sessionMetadataService
+            ?.getTranscriptDisplayObjects(sessionId)
+            .find((candidate) => candidate.id === objectId);
+        if (!object) {
+            return c.json({ error: "Transcript display object not found" }, 404);
+        }
+        if (active?.objectId === objectId && object.status === "generating") {
+            active.abortController.abort();
+        }
+        else if (object.status !== "error") {
+            return c.json({ error: "Fork summary job is not active" }, 409);
+        }
+        await deps.sessionMetadataService?.removeTranscriptDisplayObject(sessionId, objectId);
+        emitTranscriptDisplayObjects(sessionId);
+        return c.json({
+            transcriptDisplayObjects: deps.sessionMetadataService?.getTranscriptDisplayObjects(sessionId) ??
+                [],
+        });
+    });
+    routes.patch("/projects/:projectId/sessions/:sessionId/fork-summary/:objectId", async (c) => {
+        const projectId = c.req.param("projectId");
+        const sessionId = c.req.param("sessionId");
+        const objectId = c.req.param("objectId");
+        if (!isUrlProjectId(projectId)) {
+            return c.json({ error: "Invalid project ID format" }, 400);
+        }
+        if (!deps.sessionMetadataService) {
+            return c.json({ error: "Session metadata service not available" }, 503);
+        }
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: "Invalid JSON body" }, 400);
+        }
+        const action = body.action === "opened" || body.action === "clicked"
+            ? body.action
+            : undefined;
+        if (body.autoOpenWhenReady !== undefined &&
+            typeof body.autoOpenWhenReady !== "boolean") {
+            return c.json({ error: "autoOpenWhenReady must be a boolean" }, 400);
+        }
+        if (body.action !== undefined && !action) {
+            return c.json({ error: "action must be opened or clicked" }, 400);
+        }
+        const now = new Date().toISOString();
+        const updated = await deps.sessionMetadataService.updateTranscriptDisplayObject(sessionId, objectId, (object) => ({
+            ...object,
+            ...(typeof body.autoOpenWhenReady === "boolean"
+                ? { autoOpenWhenReady: body.autoOpenWhenReady || undefined }
+                : {}),
+            ...(action === "opened" ? { openedAt: now } : {}),
+            ...(action === "clicked" ? { clickedAt: now } : {}),
+        }));
+        if (!updated) {
+            return c.json({ error: "Transcript display object not found" }, 404);
+        }
+        emitTranscriptDisplayObjects(sessionId);
+        return c.json({
+            displayObject: updated,
+            transcriptDisplayObjects: deps.sessionMetadataService.getTranscriptDisplayObjects(sessionId),
+        });
+    });
+    // POST /api/sessions/:sessionId/messages - Queue message
+    routes.post("/sessions/:sessionId/messages", async (c) => {
+        const sessionId = c.req.param("sessionId");
+        const process = deps.supervisor.getProcessForSession(sessionId);
+        if (!process) {
+            return c.json({ error: "No active process for session" }, 404);
+        }
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: "Invalid JSON body" }, 400);
+        }
+        if (!body.message) {
+            return c.json({ error: "Message is required" }, 400);
+        }
+        const serverTimestamp = Date.now();
+        const userMessage = {
+            text: body.message,
+            images: body.images,
+            documents: body.documents,
+            attachments: body.attachments,
+            mode: body.mode,
+            tempId: body.tempId,
+            metadata: buildUserMessageMetadata(body, serverTimestamp, body.deferred ? "deferred" : "direct"),
+        };
+        // Check if process is terminated
+        if (process.isTerminated) {
+            return c.json({
+                error: "Process terminated",
+                reason: process.terminationReason,
+            }, 410); // 410 Gone
+        }
+        // Provider-native slash commands (e.g. Codex `/compact`) are dispatched
+        // through the provider's own protocol rather than delivered as turn text the
+        // model would never interpret. Claude's `/compact` reports handled:false and
+        // falls through to normal delivery so the SDK handles it as a regular turn
+        // (and any trailing focus instructions reach the SDK verbatim). A deferred
+        // submission keeps normal queue semantics.
+        if (!body.deferred) {
+            const parsed = parseSlashCommandSubmission(body.message);
+            if (parsed) {
+                const providerResult = await process.runProviderCommand(parsed.name, parsed.argument);
+                if (providerResult.handled) {
+                    if (providerResult.error) {
+                        return c.json({ error: "Failed to run command", reason: providerResult.error }, 409);
+                    }
+                    return c.json({ queued: true, serverTimestamp });
+                }
+            }
+        }
+        const resolvedModel = body.model && body.model !== "default"
+            ? body.model
+            : (process.resolvedModel ?? process.model);
         const modelInfoService = deps.modelInfoService;
         const resolveContextWindow = modelInfoService
             ? (model, provider) => modelInfoService.getContextWindow(model, provider)
@@ -2210,7 +3552,6 @@ export function createSessionsRoutes(deps) {
             await process.primeSupportedCommandsForMessage(userMessage);
             const deferredResult = process.deferMessage(userMessage, {
                 promoteIfReady: true,
-                placement: parseDeferredPlacement(body),
             });
             if (!deferredResult.success) {
                 return c.json({
@@ -2218,6 +3559,7 @@ export function createSessionsRoutes(deps) {
                     reason: deferredResult.error,
                 }, 410);
             }
+            await process.waitForPatientQueuePersistenceIdle();
             return c.json({
                 queued: true,
                 deferred: deferredResult.deferred,
@@ -2229,7 +3571,7 @@ export function createSessionsRoutes(deps) {
         }
         // Convert thinking option to SDK config
         const { thinking, effort } = body.thinking
-            ? thinkingOptionToConfig(body.thinking)
+            ? thinkingOptionToConfig(body.thinking, body.showThinking)
             : { thinking: undefined, effort: undefined };
         const metadataProvider = deps.sessionMetadataService?.getProvider(sessionId);
         const metadataExecutor = parseOptionalExecutor(deps.sessionMetadataService?.getExecutor(sessionId));
@@ -2244,9 +3586,26 @@ export function createSessionsRoutes(deps) {
             ? body.model
             : (process.resolvedModel ?? process.model);
         const serviceTier = normalizeOptionalServiceTier(body.serviceTier);
+        // Per-model preemptive-compaction threshold (task 029). The route holds the
+        // settings; the Supervisor stays settings-agnostic. Key strictly by the YA
+        // model id: the alias the user picked this turn, else the live requested
+        // alias, else the alias persisted at launch (survives restart), else the
+        // provider's reported→YA-id helper for sessions YA didn't start. No family
+        // fallback. See topics/provider-abstraction.md § Per-model settings keying.
+        const yaModelId = body.model ??
+            process.requestedModel ??
+            deps.sessionMetadataService?.getRequestedModel(sessionId) ??
+            getProvider(process.provider)?.yaModelIdForReported?.(process.resolvedModel);
+        const compactAtContextPercent = resolveCompactPercent(deps.serverSettingsService?.getSetting("clientDefaults")
+            ?.compactAtContextPercent, yaModelId);
+        // Resolve the effective window here too — process.contextWindow is
+        // unreliable (often undefined) and the base resolver ignores always-1M.
+        const compactAtContextWindow = compactAtContextPercent === undefined
+            ? undefined
+            : resolveCompactWindow(process.provider, [yaModelId, process.resolvedModel, process.model], resolveContextWindow);
         // Use queueMessageToSession which handles thinking mode changes
         // If thinking mode changed, it will restart the process automatically
-        const queueGlobalInstructions = deps.serverSettingsService?.getSetting("globalInstructions") || undefined;
+        const queueGlobalInstructions = getGlobalInstructions();
         const result = await deps.supervisor.queueMessageToSession(sessionId, process.projectPath, userMessage, body.mode, {
             model,
             serviceTier,
@@ -2259,6 +3618,8 @@ export function createSessionsRoutes(deps) {
                 undefined,
             globalInstructions: queueGlobalInstructions,
             permissions: body.permissions,
+            compactAtContextPercent,
+            compactAtContextWindow,
         });
         if (!result.success) {
             return c.json({
@@ -2274,52 +3635,267 @@ export function createSessionsRoutes(deps) {
             serverTimestamp,
         });
     });
-    // DELETE /api/sessions/:sessionId/deferred/:tempId - Cancel a deferred message
-    routes.delete("/sessions/:sessionId/deferred/:tempId", (c) => {
+    // DELETE /api/sessions/:sessionId/recovered-queue/:queueId - Delete a
+    // restart-paused patient queue entry by durable queue id.
+    routes.delete("/sessions/:sessionId/recovered-queue/:queueId", async (c) => {
         const sessionId = c.req.param("sessionId");
-        const tempId = c.req.param("tempId");
-        const process = deps.supervisor.getProcessForSession(sessionId);
+        const queueId = c.req.param("queueId");
+        const service = deps.sessionQueuePersistenceService;
+        if (!service) {
+            return c.json({ error: "Session queue persistence unavailable" }, 503);
+        }
+        const item = service
+            .listSession(sessionId)
+            .find((candidate) => candidate.id === queueId);
+        if (item?.kind !== "patient" || item.status !== "paused-after-restart") {
+            return c.json({ error: "Recovered queued message not found" }, 404);
+        }
+        await service.deleteItem(queueId);
+        return c.json({
+            deleted: true,
+            deferredMessages: recoveredPatientQueueSummaries(deps, sessionId),
+        });
+    });
+    // A recovered patient queue entry may need a fresh process before it can
+    // rejoin the live queue. Shared by the recovered-queue resume/steer routes.
+    const ensureProcessForRecoveredItem = async (sessionId, item, existing) => {
+        let process = existing;
+        const mode = item.message.mode ?? item.mode;
+        const metadata = deps.sessionMetadataService?.getMetadata(sessionId);
+        const parsedExecutor = parseOptionalExecutor(item.executor ?? metadata?.executor);
+        if (parsedExecutor.error) {
+            return { error: parsedExecutor.error, status: 400 };
+        }
+        const rawModel = item.model ?? metadata?.requestedModel;
+        const model = rawModel && rawModel !== "default" ? rawModel : undefined;
         if (!process) {
-            return c.json({ error: "No active process for session" }, 404);
+            try {
+                process = await deps.supervisor.reactivateSession(item.projectPath, sessionId, mode, {
+                    model,
+                    serviceTier: item.serviceTier,
+                    providerName: item.provider,
+                    executor: parsedExecutor.executor,
+                    globalInstructions: getGlobalInstructions(),
+                    recapAfterSeconds: metadata?.recapAfterSeconds,
+                    promptSuggestionMode: metadata?.promptSuggestionMode,
+                });
+            }
+            catch (error) {
+                return {
+                    error: error instanceof Error
+                        ? error.message
+                        : "Failed to reactivate session",
+                    status: 503,
+                };
+            }
+            await persistLaunchMetadata(sessionId, item.provider, parsedExecutor.executor, undefined, item.model ?? metadata?.requestedModel, metadata?.promptSuggestionMode, metadata?.recapAfterSeconds);
         }
-        const cancelled = process.cancelDeferredMessage(tempId);
-        if (!cancelled) {
-            return c.json({ error: "Deferred message not found" }, 404);
+        else if (mode) {
+            process.setPermissionMode(mode);
         }
-        return c.json({ cancelled: true });
+        return { process };
+    };
+    // Move recovered entries back into the live patient queue in queuedAt
+    // order. On a mid-group failure the earlier resumes stand; the caller
+    // reports the failed entry.
+    const resumeRecoveredGroup = async (process, group, options) => {
+        let last;
+        let lastMessage;
+        for (const item of group) {
+            const userMessage = recoveredPatientUserMessage(item);
+            await process.primeSupportedCommandsForMessage(userMessage);
+            const result = process.deferMessage(userMessage, {
+                promoteIfReady: options.promoteIfReady,
+                persistedQueueId: item.id,
+                timestamp: item.queuedAt,
+            });
+            if (!result.success) {
+                return {
+                    last,
+                    lastMessage,
+                    error: result.error ?? "Failed to queue message",
+                };
+            }
+            last = result;
+            lastMessage = userMessage;
+        }
+        return { last, lastMessage };
+    };
+    const reportableProcessState = (process) => process.state.type === "waiting-input" || process.state.type === "in-turn"
+        ? process.state.type
+        : "idle";
+    // Shared prologue for the recovered-queue resume/steer routes: resolve the
+    // target and the recovered group composed before it, refuse while newer
+    // live patient entries exist, and ensure a live process. The newer-entries
+    // guard runs again after the ensure — its await is a window for new
+    // arrivals, and recovered context must never jump a newer patient entry.
+    const resolveRecoveredGroupForDelivery = async (sessionId, queueId, refusal) => {
+        if (!deps.sessionQueuePersistenceService) {
+            return {
+                ok: false,
+                status: 503,
+                body: { error: "Session queue persistence unavailable" },
+            };
+        }
+        const recoveredItems = recoveredPatientQueueItems(deps, sessionId);
+        const targetIndex = recoveredItems.findIndex((candidate) => candidate.id === queueId);
+        const target = recoveredItems[targetIndex];
+        if (!target) {
+            return {
+                ok: false,
+                status: 404,
+                body: { error: "Recovered queued message not found" },
+            };
+        }
+        const group = recoveredItems.slice(0, targetIndex + 1);
+        let process = deps.supervisor.getProcessForSession(sessionId);
+        if (process?.isTerminated) {
+            process = undefined;
+        }
+        const refuseIfNewerEntries = (candidate) => livePatientEntriesNewerThan(candidate, target.queuedAt) > 0
+            ? {
+                ok: false,
+                status: 409,
+                body: {
+                    error: refusal,
+                    headQueueId: target.id,
+                    deferredMessages: sessionQueueSummaries(deps, sessionId, candidate),
+                },
+            }
+            : null;
+        const refusedBefore = refuseIfNewerEntries(process);
+        if (refusedBefore) {
+            return refusedBefore;
+        }
+        const ensured = await ensureProcessForRecoveredItem(sessionId, target, process);
+        if ("error" in ensured) {
+            return {
+                ok: false,
+                status: ensured.status,
+                body: { error: ensured.error },
+            };
+        }
+        process = ensured.process;
+        const refusedAfter = refuseIfNewerEntries(process);
+        if (refusedAfter) {
+            return refusedAfter;
+        }
+        return { ok: true, process, group };
+    };
+    // POST /api/sessions/:sessionId/recovered-queue/:queueId/resume - Move
+    // restart-paused patient queue entries back into the live patient queue,
+    // through the requested entry: resuming a non-head entry also resumes every
+    // recovered entry before it, so compose order is preserved.
+    routes.post("/sessions/:sessionId/recovered-queue/:queueId/resume", async (c) => {
+        const sessionId = c.req.param("sessionId");
+        const queueId = c.req.param("queueId");
+        const resolved = await resolveRecoveredGroupForDelivery(sessionId, queueId, "Drain or cancel newer queued messages before resuming recovered work.");
+        if (!resolved.ok) {
+            return c.json(resolved.body, resolved.status);
+        }
+        const { process, group } = resolved;
+        const { last, error } = await resumeRecoveredGroup(process, group, {
+            promoteIfReady: true,
+        });
+        if (error || !last) {
+            return c.json({
+                error: "Failed to resume recovered queued message",
+                reason: error,
+                deferredMessages: sessionQueueSummaries(deps, sessionId, process),
+            }, 409);
+        }
+        await process.waitForPatientQueuePersistenceIdle();
+        return c.json({
+            resumed: true,
+            resumedCount: group.length,
+            deferred: last.deferred,
+            promoted: last.promoted,
+            position: last.position,
+            processId: process.id,
+            processState: reportableProcessState(process),
+            permissionMode: process.permissionMode,
+            modeVersion: process.modeVersion,
+            recapAfterSeconds: process.recapAfterSeconds,
+            deferredMessages: sessionQueueSummaries(deps, sessionId, process),
+            serverTimestamp: Date.now(),
+        });
     });
-    // POST /api/sessions/:sessionId/deferred/:tempId/edit - Take a deferred message for editing
-    routes.post("/sessions/:sessionId/deferred/:tempId/edit", (c) => {
+    // POST /api/sessions/:sessionId/recovered-queue/:queueId/steer - Steer a
+    // restart-paused patient queue entry into the session now, without waiting
+    // for verified quiet: the entry and every recovered or live patient entry
+    // composed before it rejoin the live queue and steer in compose order.
+    routes.post("/sessions/:sessionId/recovered-queue/:queueId/steer", async (c) => {
+        const sessionId = c.req.param("sessionId");
+        const queueId = c.req.param("queueId");
+        const resolved = await resolveRecoveredGroupForDelivery(sessionId, queueId, "Drain or cancel newer queued messages before steering recovered work.");
+        if (!resolved.ok) {
+            return c.json(resolved.body, resolved.status);
+        }
+        const { process, group } = resolved;
+        const { lastMessage, error } = await resumeRecoveredGroup(process, group, { promoteIfReady: false });
+        if (error || !lastMessage?.tempId) {
+            return c.json({
+                error: "Failed to steer recovered queued message",
+                reason: error,
+                deferredMessages: sessionQueueSummaries(deps, sessionId, process),
+            }, 409);
+        }
+        const steerResult = process.steerPatientDeferredMessagesThrough(lastMessage.tempId);
+        if (!steerResult.success) {
+            return c.json({
+                error: steerResult.error ?? "Failed to steer recovered queued message",
+                deferredMessages: sessionQueueSummaries(deps, sessionId, process),
+            }, 409);
+        }
+        await process.waitForPatientQueuePersistenceIdle();
+        return c.json({
+            steered: true,
+            count: steerResult.steered,
+            processId: process.id,
+            processState: reportableProcessState(process),
+            permissionMode: process.permissionMode,
+            modeVersion: process.modeVersion,
+            recapAfterSeconds: process.recapAfterSeconds,
+            deferredMessages: sessionQueueSummaries(deps, sessionId, process),
+            serverTimestamp: Date.now(),
+        });
+    });
+    // DELETE /api/sessions/:sessionId/deferred/:tempId - Cancel a deferred message
+    routes.delete("/sessions/:sessionId/deferred/:tempId", async (c) => {
         const sessionId = c.req.param("sessionId");
         const tempId = c.req.param("tempId");
         const process = deps.supervisor.getProcessForSession(sessionId);
         if (!process) {
             return c.json({ error: "No active process for session" }, 404);
         }
-        const taken = process.takeDeferredMessage(tempId);
-        if (!taken) {
+        const cancelled = process.cancelDeferredMessage(tempId);
+        if (!cancelled) {
             return c.json({ error: "Deferred message not found" }, 404);
         }
-        return c.json({
-            message: taken.message.text,
-            tempId: taken.message.tempId,
-            mode: taken.message.mode,
-            attachments: taken.message.attachments,
-            placement: taken.placement,
-        });
+        await process.waitForPatientQueuePersistenceIdle();
+        return c.json({ cancelled: true });
     });
-    // POST /api/sessions/:sessionId/deferred/:tempId/edit/release - Release a queued edit barrier
-    routes.post("/sessions/:sessionId/deferred/:tempId/edit/release", (c) => {
+    // POST /api/sessions/:sessionId/deferred/:tempId/steer - Steer a patient
+    // queued message, and every patient entry ahead of it, into the session now.
+    routes.post("/sessions/:sessionId/deferred/:tempId/steer", async (c) => {
         const sessionId = c.req.param("sessionId");
         const tempId = c.req.param("tempId");
         const process = deps.supervisor.getProcessForSession(sessionId);
         if (!process) {
             return c.json({ error: "No active process for session" }, 404);
         }
-        const released = process.releaseDeferredEditBarrier(tempId);
+        const result = process.steerPatientDeferredMessagesThrough(tempId);
+        if (!result.success) {
+            const status = result.error === "Deferred message not found" ? 404 : 409;
+            return c.json({ error: result.error }, status);
+        }
+        await process.waitForPatientQueuePersistenceIdle();
         return c.json({
-            released,
-            deferredMessages: process.getDeferredQueueSummary(),
+            steered: true,
+            count: result.steered,
+            // Include any still-paused recovered entries so the client's list does
+            // not lose their chips when a live entry is steered.
+            deferredMessages: sessionQueueSummaries(deps, sessionId, process),
         });
     });
     // PUT /api/sessions/:sessionId/mode - Update permission mode without sending a message
@@ -2387,32 +3963,65 @@ export function createSessionsRoutes(deps) {
         const requestBefore = process.getPendingInputRequest();
         const permissionModeBefore = process.permissionMode;
         if (process.state.type !== "waiting-input") {
-            try {
-                await appendApprovalAuditLog(deps.dataDir, {
-                    timestamp: new Date().toISOString(),
-                    sessionId,
-                    processId: process.id,
-                    provider: process.provider,
-                    requestId: body.requestId,
-                    request: requestBefore,
-                    response: body.response,
-                    normalizedResponse,
-                    answers: body.answers,
-                    feedback: body.feedback,
-                    accepted: false,
-                    failure: "No pending input request",
-                    permissionModeBefore,
-                    permissionModeAfter: process.permissionMode,
-                });
-            }
-            catch (error) {
-                console.warn("[approval-audit] Failed to append audit log:", error);
+            if (isApprovalAuditLogEnabled(deps)) {
+                try {
+                    await appendApprovalAuditLog(deps.dataDir, {
+                        timestamp: new Date().toISOString(),
+                        sessionId,
+                        processId: process.id,
+                        provider: process.provider,
+                        requestId: body.requestId,
+                        request: requestBefore,
+                        response: body.response,
+                        normalizedResponse,
+                        answers: body.answers,
+                        feedback: body.feedback,
+                        accepted: false,
+                        failure: "No pending input request",
+                        permissionModeBefore,
+                        permissionModeAfter: process.permissionMode,
+                    });
+                }
+                catch (error) {
+                    console.warn("[approval-audit] Failed to append audit log:", error);
+                }
             }
             return c.json({ error: "No pending input request" }, 400);
         }
         // Call respondToInput which resolves the SDK's canUseTool promise
         const accepted = process.respondToInput(body.requestId, normalizedResponse, body.answers, body.feedback);
         if (!accepted) {
+            if (isApprovalAuditLogEnabled(deps)) {
+                try {
+                    await appendApprovalAuditLog(deps.dataDir, {
+                        timestamp: new Date().toISOString(),
+                        sessionId,
+                        processId: process.id,
+                        provider: process.provider,
+                        requestId: body.requestId,
+                        request: requestBefore,
+                        response: body.response,
+                        normalizedResponse,
+                        answers: body.answers,
+                        feedback: body.feedback,
+                        accepted: false,
+                        failure: "Invalid request ID or no pending request",
+                        permissionModeBefore,
+                        permissionModeAfter: process.permissionMode,
+                    });
+                }
+                catch (error) {
+                    console.warn("[approval-audit] Failed to append audit log:", error);
+                }
+            }
+            return c.json({ error: "Invalid request ID or no pending request" }, 400);
+        }
+        // If approve_accept_edits, switch the permission mode
+        if (isApproveAcceptEdits) {
+            process.setPermissionMode("acceptEdits");
+        }
+        const pendingInputRequest = process.getPendingInputRequest();
+        if (isApprovalAuditLogEnabled(deps)) {
             try {
                 await appendApprovalAuditLog(deps.dataDir, {
                     timestamp: new Date().toISOString(),
@@ -2425,8 +4034,7 @@ export function createSessionsRoutes(deps) {
                     normalizedResponse,
                     answers: body.answers,
                     feedback: body.feedback,
-                    accepted: false,
-                    failure: "Invalid request ID or no pending request",
+                    accepted: true,
                     permissionModeBefore,
                     permissionModeAfter: process.permissionMode,
                 });
@@ -2434,32 +4042,6 @@ export function createSessionsRoutes(deps) {
             catch (error) {
                 console.warn("[approval-audit] Failed to append audit log:", error);
             }
-            return c.json({ error: "Invalid request ID or no pending request" }, 400);
-        }
-        // If approve_accept_edits, switch the permission mode
-        if (isApproveAcceptEdits) {
-            process.setPermissionMode("acceptEdits");
-        }
-        const pendingInputRequest = process.getPendingInputRequest();
-        try {
-            await appendApprovalAuditLog(deps.dataDir, {
-                timestamp: new Date().toISOString(),
-                sessionId,
-                processId: process.id,
-                provider: process.provider,
-                requestId: body.requestId,
-                request: requestBefore,
-                response: body.response,
-                normalizedResponse,
-                answers: body.answers,
-                feedback: body.feedback,
-                accepted: true,
-                permissionModeBefore,
-                permissionModeAfter: process.permissionMode,
-            });
-        }
-        catch (error) {
-            console.warn("[approval-audit] Failed to append audit log:", error);
         }
         return c.json({ accepted: true, pendingInputRequest });
     });
@@ -2542,7 +4124,9 @@ export function createSessionsRoutes(deps) {
             body.heartbeatTurnsEnabled === undefined &&
             body.heartbeatTurnsAfterMinutes === undefined &&
             body.heartbeatTurnText === undefined &&
-            body.heartbeatForceAfterMinutes === undefined) {
+            body.heartbeatForceAfterMinutes === undefined &&
+            body.promptSuggestionMode === undefined &&
+            body.recapAfterSeconds === undefined) {
             return c.json({
                 error: "At least one session metadata field must be provided",
             }, 400);
@@ -2606,6 +4190,36 @@ export function createSessionsRoutes(deps) {
             : typeof body.parentSessionId === "string"
                 ? body.parentSessionId.trim() || null
                 : null;
+        // promptSuggestionMode: null/"" clears the preference (revert to default);
+        // a valid enum value is stored; any other value is rejected.
+        let promptSuggestionMode;
+        if (body.promptSuggestionMode !== undefined) {
+            if (body.promptSuggestionMode === null ||
+                body.promptSuggestionMode === "") {
+                promptSuggestionMode = null;
+            }
+            else if (typeof body.promptSuggestionMode === "string" &&
+                PROMPT_SUGGESTION_MODES.includes(body.promptSuggestionMode)) {
+                promptSuggestionMode =
+                    body.promptSuggestionMode;
+            }
+            else {
+                return c.json({ error: "promptSuggestionMode must be one of: off, native" }, 400);
+            }
+        }
+        let recapAfterSeconds;
+        if (body.recapAfterSeconds !== undefined) {
+            if (body.recapAfterSeconds === null || body.recapAfterSeconds === "") {
+                recapAfterSeconds = null;
+            }
+            else if (typeof body.recapAfterSeconds === "number" &&
+                Number.isFinite(body.recapAfterSeconds)) {
+                recapAfterSeconds = clampRecapAfterSeconds(body.recapAfterSeconds);
+            }
+            else {
+                return c.json({ error: "recapAfterSeconds must be null or a finite number" }, 400);
+            }
+        }
         await deps.sessionMetadataService.updateMetadata(sessionId, {
             title: body.title,
             archived: body.archived,
@@ -2615,6 +4229,8 @@ export function createSessionsRoutes(deps) {
             heartbeatTurnsAfterMinutes,
             heartbeatTurnText,
             heartbeatForceAfterMinutes,
+            promptSuggestionMode,
+            recapAfterSeconds,
         });
         // Emit SSE event so sidebar and other clients can update
         if (deps.eventBus) {
@@ -2629,6 +4245,8 @@ export function createSessionsRoutes(deps) {
                 heartbeatTurnsAfterMinutes,
                 heartbeatTurnText,
                 heartbeatForceAfterMinutes,
+                promptSuggestionMode: promptSuggestionMode ?? undefined,
+                recapAfterSeconds: recapAfterSeconds ?? undefined,
                 timestamp: new Date().toISOString(),
             });
         }
@@ -2674,7 +4292,7 @@ export function createSessionsRoutes(deps) {
             }
             // Get original session to extract title for the clone
             const reader = deps.readerFactory(project);
-            let originalSession = await reader.getSessionSummary(sessionId, projectId);
+            let originalSession = await reader.getSessionSummary(sessionId, projectId, { readMode: "head" });
             let cloneProvider = project.provider;
             let result;
             const shouldCloneFromCodex = isCodexProviderName(body.provider) ||
@@ -2691,7 +4309,9 @@ export function createSessionsRoutes(deps) {
                 }
                 originalSession =
                     originalSession ??
-                        (await codexReader.getSessionSummary(sessionId, projectId)) ??
+                        (await codexReader.getSessionSummary(sessionId, projectId, {
+                            readMode: "head",
+                        })) ??
                         null;
                 cloneProvider =
                     originalSession?.provider ??
@@ -2734,36 +4354,6 @@ export function createSessionsRoutes(deps) {
             return c.json({ error: message }, 500);
         }
     });
-    // ============ Worker Queue Endpoints ============
-    // GET /api/status/workers - Get worker activity for safe restart indicator
-    routes.get("/status/workers", (c) => {
-        const activity = deps.supervisor.getWorkerActivity();
-        return c.json(activity);
-    });
-    // GET /api/queue - Get all queued requests
-    routes.get("/queue", (c) => {
-        const queue = deps.supervisor.getQueueInfo();
-        const poolStatus = deps.supervisor.getWorkerPoolStatus();
-        return c.json({ queue, ...poolStatus });
-    });
-    // GET /api/queue/:queueId - Get specific queue entry position
-    routes.get("/queue/:queueId", (c) => {
-        const queueId = c.req.param("queueId");
-        const position = deps.supervisor.getQueuePosition(queueId);
-        if (position === undefined) {
-            return c.json({ error: "Queue entry not found" }, 404);
-        }
-        return c.json({ queueId, position });
-    });
-    // DELETE /api/queue/:queueId - Cancel a queued request
-    routes.delete("/queue/:queueId", (c) => {
-        const queueId = c.req.param("queueId");
-        const cancelled = deps.supervisor.cancelQueuedRequest(queueId);
-        if (!cancelled) {
-            return c.json({ error: "Queue entry not found or already processed" }, 404);
-        }
-        return c.json({ cancelled: true });
-    });
     return routes;
 }
 //# sourceMappingURL=sessions.js.map