@gkorepanov/ccodex 0.4.19 → 0.4.23

package/dist/claude/service.js

@@ -7,14 +7,15 @@ import { SqliteHybridStore } from "../store/sqliteStore.js";
 import { LayeredHybridStore } from "../store/memoryStore.js";
 import { createClaudeQuery } from "./queryFactory.js";
 import { claudeEnvironment } from "./environment.js";
-import { invalidParams } from "../protocol/errors.js";
-import { paginateTurns, turnCursor } from "../protocol/turnPagination.js";
+import { invalidParams, invalidRequest } from "../protocol/errors.js";
+import { historyCursors, paginateItems, paginateTurns, startedTurn } from "../protocol/turnPagination.js";
+import { searchTurnOccurrences, threadSearchSnippet } from "../protocol/search.js";
 import { MetricsRegistry } from "../observability/metrics.js";
 import { SdkTranscriptBrancher, } from "./transcriptBrancher.js";
 import { ClaudeRateLimitCoordinator, } from "./rateLimits.js";
 import { isClaudeStatusCommand } from "./statusCommand.js";
 import { systemNoticeText } from "../gateway/transientNotice.js";
-import { claudeCatalogId, normalizeClaudeModelIdentifier, normalizeClaudeServiceTier, resolveClaudeModel, } from "./modelSelection.js";
+import { claudeCatalogId, normalizeClaudeModelIdentifier, normalizeClaudeServiceTier, pickClaudeModelReplacement, resolveClaudeModel, } from "./modelSelection.js";
 import { ClaudeOutputAdapter } from "./session/outputAdapter.js";
 import { branchRevision, ClaudeSessionRepository } from "./session/repository.js";
 import { ActiveClaudeTurnError, ClaudeSession } from "./session/session.js";
@@ -159,7 +160,9 @@ function threadResponse(record, includeTurns) {
         ...settings,
         thread: {
             ...record.thread,
-            isPinned: record.thread.isPinned ?? false,
+            section: record.thread.section ?? null,
+            sectionEnteredAt: record.thread.sectionEnteredAt ?? null,
+            projectId: record.thread.projectId ?? null,
             canAcceptDirectInput: record.thread.parentThreadId ? false : true,
             turns: includeTurns ? record.thread.turns : [],
         },
@@ -255,6 +258,8 @@ export class ClaudeService {
     nativeSessionCatalog;
     ephemeralReleases = new Map();
     ephemeralReleaseTimers = new Map();
+    /** Root threads whose last turn completed or failed and whose queue drains once the session is quiescent. */
+    queueDrainPending = new Set();
     removalRetries = new Map();
     terminalAdmins = new Map();
     settingsUpdates = new Map();
@@ -290,7 +295,7 @@ export class ClaudeService {
         const sessionRepository = new ClaudeSessionRepository(this.store);
         this.sessionOutput = new ClaudeOutputAdapter(hub);
         this.rateLimits = new ClaudeRateLimitCoordinator(logger);
-        this.sessions = new ClaudeSessionRegistry((threadId) => new ClaudeSession(threadId, sessionRepository, this.sessionOutput, undefined, metrics, undefined, (childThreadId) => this.sessions.registerChild(childThreadId, threadId), (childThreadId) => this.sessions.unregisterChild(childThreadId), shellRunner, undefined, {
+        this.sessions = new ClaudeSessionRegistry((threadId) => new ClaudeSession(threadId, sessionRepository, this.sessionOutput, undefined, metrics, (update) => this.onSessionLifecycle(threadId, update), (childThreadId) => this.sessions.registerChild(childThreadId, threadId), (childThreadId) => this.sessions.unregisterChild(childThreadId), shellRunner, undefined, {
             claudeBinary: this.config.claudeBinary,
             logger: this.logger,
             queryFactory: this.queryFactory,
@@ -303,10 +308,12 @@ export class ClaudeService {
             interactiveQuestions: this.config.features?.interactiveQuestions ?? true,
             resolveChildModel: (model) => {
                 const value = normalizeClaudeModelIdentifier(model);
-                const modelPickerId = this.modelCatalog?.cachedPickerId?.(value)
-                    ?? (value.startsWith(this.config.modelPrefix) ? value : `${this.config.modelPrefix}${value}`);
+                const modelPickerId = value.startsWith(this.config.modelPrefix) ? value : `${this.config.modelPrefix}${value}`;
                 const claudeModelValue = resolveClaudeModel(this.config, modelPickerId);
-                return claudeModelValue ? { modelPickerId, claudeModelValue } : undefined;
+                if (!claudeModelValue)
+                    return undefined;
+                const lookup = this.cachedCatalogLookup(claudeModelValue);
+                return lookup ? this.catalogSelection(modelPickerId, claudeModelValue, lookup) : { modelPickerId, claudeModelValue };
             },
         }));
         const records = this.store.allThreadRecords();
@@ -418,11 +425,47 @@ export class ClaudeService {
         return threadSettings(this.withCatalogModel(this.requireRecord(threadId, false)));
     }
     withCatalogModel(record) {
-        const modelPickerId = this.modelCatalog?.cachedPickerId?.(record.resolvedModel ?? record.claudeModelValue);
-        if (!modelPickerId || modelPickerId === record.modelPickerId)
+        const lookup = this.cachedCatalogLookup(record.resolvedModel ?? record.claudeModelValue);
+        if (!lookup)
             return record;
-        const claudeModelValue = resolveClaudeModel(this.config, modelPickerId);
-        return claudeModelValue ? { ...record, modelPickerId, claudeModelValue } : record;
+        const selection = this.catalogSelection(record.modelPickerId, record.claudeModelValue, lookup);
+        return selection.modelPickerId === record.modelPickerId ? record : { ...record, ...selection };
+    }
+    /** Finds the catalog entry for a Claude model value, migrating retired ids onto the closest current model. */
+    catalogLookup(models, claudeModelValue) {
+        const catalog = this.modelCatalog;
+        const cached = catalog.cachedPickerId?.(claudeModelValue);
+        if (cached)
+            return { id: cached, model: models.find((candidate) => candidate.id === cached), reason: "exact" };
+        const prefix = this.config.modelPrefix;
+        const strip = (id) => id.slice(prefix.length);
+        const defaultId = catalog.defaultModelId?.();
+        const replacement = pickClaudeModelReplacement(claudeModelValue, models.map((candidate) => strip(candidate.id)), defaultId && strip(defaultId));
+        const model = replacement && models.find((candidate) => strip(candidate.id) === replacement.value);
+        return model ? { id: model.id, model, reason: replacement.reason } : undefined;
+    }
+    cachedCatalogLookup(claudeModelValue) {
+        return this.modelCatalog && this.catalogLookup(this.modelCatalog.cachedModels?.() ?? [], claudeModelValue);
+    }
+    catalogSelection(modelPickerId, claudeModelValue, lookup) {
+        const prefix = this.config.modelPrefix;
+        if (lookup.id === `${prefix}${claudeModelValue}` || lookup.id === claudeCatalogId(this.config, modelPickerId))
+            return { modelPickerId, claudeModelValue };
+        this.logger.warn("claude.model.migrated", { from: modelPickerId, to: lookup.id, reason: lookup.reason });
+        return { modelPickerId: lookup.id, claudeModelValue: lookup.id.slice(prefix.length) };
+    }
+    /** Persists a catalog migration for a stored thread so its runtime starts on a model the account still has. */
+    async migrateStoredModel(threadId) {
+        if (!this.modelCatalog)
+            return;
+        const record = this.requireRecord(threadId, false);
+        const models = await this.modelCatalog.list().catch(() => undefined);
+        const lookup = models && this.catalogLookup(models, record.claudeModelValue);
+        if (!lookup)
+            return;
+        const selection = this.catalogSelection(record.modelPickerId, record.claudeModelValue, lookup);
+        if (selection.modelPickerId !== record.modelPickerId)
+            await this.applySettings({ threadId, model: selection.modelPickerId });
     }
     sideSnapshot(sourceThreadId, targetThreadId, visibleForkedFromId) {
         const record = this.requireRecord(sourceThreadId, false);
@@ -508,10 +551,10 @@ export class ClaudeService {
             throw invalidParams(`Unknown Claude thread '${threadId}'.`);
         if (record.thread.parentThreadId) {
             record = this.withCatalogModel(record);
+            record = { ...record, thread: this.withNativeMetadata(record) };
             return {
                 ...threadResponse(record, !resume.excludeTurns),
-                turnsBackwardsCursor: record.thread.turns.length ? turnCursor(record.thread.turns.at(-1).id, true) : null,
-                itemsBackwardsCursor: record.thread.turns.some((turn) => turn.items.length) ? "hyb-item:0" : null,
+                ...historyCursors(record.thread.turns),
                 initialTurnsPage: resume.initialTurnsPage
                     ? this.turnsPage({
                         threadId,
@@ -531,13 +574,16 @@ export class ClaudeService {
                     : {}),
             });
         }
+        await this.migrateStoredModel(threadId);
         await (await this.sessions.getOrCreate(threadId)).materializeRuntime();
         record = await this.sessions.submit(threadId, { type: "readThread", includeTurns: true });
         record = this.withCatalogModel(record);
+        record = { ...record, thread: this.withNativeMetadata(record) };
+        if (this.store.listQueuedSubmissions(threadId).length)
+            this.scheduleQueueDrain(threadId);
         return {
             ...threadResponse(record, !resume.excludeTurns),
-            turnsBackwardsCursor: record.thread.turns.length ? turnCursor(record.thread.turns.at(-1).id, true) : null,
-            itemsBackwardsCursor: record.thread.turns.some((turn) => turn.items.length) ? "hyb-item:0" : null,
+            ...historyCursors(record.thread.turns),
             initialTurnsPage: resume.initialTurnsPage
                 ? this.turnsPage({
                     threadId,
@@ -588,6 +634,10 @@ export class ClaudeService {
     }
     async prepareTurn(params, review) {
         this.requireIndependentThread(params.threadId, "start a turn in");
+        if (params.toolOutput)
+            throw invalidParams("Claude threads do not support toolOutput.");
+        if (params.serviceTierForTurn != null)
+            this.logger.warn("claude.turn.service-tier-for-turn.ignored", { threadId: params.threadId, serviceTierForTurn: params.serviceTierForTurn });
         const availability = await this.availabilityProbe();
         if (availability.state !== "ready")
             throw invalidParams(providerUnavailableMessage(availability));
@@ -614,7 +664,8 @@ export class ClaudeService {
             let announcement;
             const startAndWait = () => announcement ? announcement.then(startRuntime) : startRuntime();
             return {
-                response: { turn: prepared.turn },
+                response: { turn: startedTurn(prepared.turn) },
+                turn: prepared.turn,
                 announce: () => announcement ??= this.sessions.submit(params.threadId, { type: "announceTurn", turnId: prepared.turn.id }),
                 start: () => {
                     void startAndWait().catch((error) => this.logger.error("claude.turn.start-failed", { threadId: params.threadId, error: String(error) }));
@@ -850,7 +901,10 @@ export class ClaudeService {
     }
     async shellCommand(params) {
         this.requireIndependentThread(params.threadId, "run a shell command in");
-        await this.sessions.submit(params.threadId, { type: "runShell", command: params.command });
+        const timeoutMs = params.timeoutMs ?? 3_600_000;
+        if (timeoutMs < 0)
+            throw invalidParams(`thread/shellCommand timeoutMs must be non-negative, got ${timeoutMs}`);
+        await this.sessions.submit(params.threadId, { type: "runShell", command: params.command, timeoutMs });
         return {};
     }
     async prepareReview(params) {
@@ -873,6 +927,8 @@ export class ClaudeService {
         let reviewThreadId = params.threadId;
         let forkedThread;
         if (params.delivery === "detached") {
+            if (this.requireRecord(params.threadId, false).thread.historyMode === "paginated")
+                throw invalidRequest("paginated threads do not support detached review");
             const fork = await this.forkThread({ threadId: params.threadId, excludeTurns: false });
             reviewThreadId = fork.thread.id;
             forkedThread = fork.thread;
@@ -882,7 +938,7 @@ export class ClaudeService {
                 threadId: reviewThreadId,
                 input: [{ type: "text", text: prompt, text_elements: [] }],
             }, { label: review, display: review });
-            const userItem = prepared.response.turn.items.find((item) => item.type === "userMessage");
+            const userItem = prepared.turn.items.find((item) => item.type === "userMessage");
             return {
                 response: {
                     turn: {
@@ -941,6 +997,15 @@ export class ClaudeService {
         this.nativeMetadataRead = read;
         return read;
     }
+    async setGeneratedThreadName(params, userPrompt) {
+        const record = this.requireRecord(params.threadId, false);
+        if (record.thread.parentThreadId || this.nativeMetadata.get(record.claudeSessionId)?.customTitle)
+            return;
+        await this.sessions.submit(params.threadId, {
+            type: "threadAdmin",
+            command: { kind: "generatedName", name: params.name, userPrompt },
+        });
+    }
     async setThreadName(params) {
         const record = this.requireRecord(params.threadId, false);
         if (record.thread.parentThreadId) {
@@ -967,9 +1032,20 @@ export class ClaudeService {
     }
     updateThreadMetadata(params) {
         this.requireIndependentThread(params.threadId, "update metadata for");
+        if (params.projectId !== undefined && params.projectId !== null && params.projectId !== "") {
+            throw invalidParams("Projects are not supported for Claude threads.");
+        }
         return this.sessions.submit(params.threadId, {
             type: "threadAdmin",
-            command: { kind: "metadata", gitInfo: params.gitInfo, isPinned: params.isPinned },
+            command: { kind: "metadata", gitInfo: params.gitInfo },
+        });
+    }
+    /** Section registry stays stock-owned; CCodex records only the membership. */
+    setThreadSection(threadId, section) {
+        this.requireIndependentThread(threadId, "move into a section");
+        return this.sessions.submit(threadId, {
+            type: "threadAdmin",
+            command: { kind: "metadata", gitInfo: undefined, section },
         });
     }
     async archiveThread(threadId) {
@@ -1073,61 +1149,21 @@ export class ClaudeService {
     }
     listItems(params) {
         this.assertThreadAvailable(params.threadId);
-        const items = this.store.listTurns(params.threadId)
-            .flatMap((turn) => params.turnId && turn.id !== params.turnId
-            ? []
-            : turn.items.map((item) => ({ turnId: turn.id, item })));
-        const ordered = params.sortDirection === "desc" ? [...items].reverse() : items;
-        if (params.cursor && !params.cursor.startsWith("hyb-item:"))
-            throw invalidParams("Invalid Claude item cursor.");
-        const offset = params.cursor?.startsWith("hyb-item:") ? Number(params.cursor.slice("hyb-item:".length)) : 0;
-        if (!Number.isInteger(offset) || offset < 0)
-            throw invalidParams("Invalid Claude item cursor.");
-        const limit = Math.max(1, Math.min(params.limit ?? 50, 100));
-        const data = ordered.slice(offset, offset + limit);
-        return {
-            data,
-            nextCursor: offset + data.length < ordered.length ? `hyb-item:${offset + data.length}` : null,
-            backwardsCursor: data.length > 0 ? `hyb-item:${Math.max(0, offset - limit)}` : null,
-        };
+        return paginateItems(this.store.listTurns(params.threadId), params, ["hyb-item:"]);
     }
     searchOccurrences(params) {
         this.assertThreadAvailable(params.threadId);
+        return searchTurnOccurrences(params.threadId, this.store.listTurns(params.threadId), params);
+    }
+    /** `thread/search` over durable Claude threads: one result per thread with the first matching snippet. */
+    searchThreads(params) {
         const searchTerm = params.searchTerm.trim();
-        if (!searchTerm)
-            throw invalidParams("thread/searchOccurrences requires a non-empty searchTerm.");
-        if (params.cursor && !params.cursor.startsWith("hyb-search:"))
-            throw invalidParams("Invalid Claude search cursor.");
-        const offset = params.cursor ? Number(params.cursor.slice("hyb-search:".length)) : 0;
-        if (!Number.isInteger(offset) || offset < 0)
-            throw invalidParams("Invalid Claude search cursor.");
-        const turns = this.store.listTurns(params.threadId);
-        const needle = searchTerm.toLocaleLowerCase();
-        const occurrences = turns.flatMap((turn) => turn.items.flatMap((item) => {
-            const text = item.type === "userMessage"
-                ? item.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n")
-                : item.type === "agentMessage" && item.phase !== "commentary" ? item.text : undefined;
-            if (text === undefined)
+        return this.listThreads({ archived: params.archived ?? false }).flatMap((thread) => {
+            if (thread.ephemeral)
                 return [];
-            const haystack = text.toLocaleLowerCase();
-            const matches = [];
-            for (let start = haystack.indexOf(needle); start >= 0; start = haystack.indexOf(needle, start + needle.length)) {
-                matches.push({
-                    turnId: turn.id,
-                    itemId: item.id,
-                    snippet: text,
-                    snippetMatchRange: { start, end: start + needle.length },
-                    turnCursor: turnCursor(turn.id, true),
-                });
-            }
-            return matches;
-        }));
-        const limit = Math.max(1, Math.min(params.limit ?? 50, 100));
-        const data = occurrences.slice(offset, offset + limit);
-        return {
-            data,
-            nextCursor: offset + data.length < occurrences.length ? `hyb-search:${offset + data.length}` : null,
-        };
+            const snippet = threadSearchSnippet(this.store.listTurns(thread.id), searchTerm);
+            return snippet === undefined ? [] : [{ thread: { ...thread, turns: [] }, snippet }];
+        });
     }
     async forkThread(params, visibleForkedFromId = params.threadId) {
         if (params.path)
@@ -1142,6 +1178,8 @@ export class ClaudeService {
             : undefined;
         const source = await this.sessions.submit(params.threadId, { type: "snapshotBranch" });
         const sourceRecord = source.record;
+        if (sourceRecord.thread.historyMode === "paginated" && params.ephemeral && !params.excludeTurns)
+            throw invalidRequest("ephemeral paginated thread/fork requires `excludeTurns: true`");
         const sidePromotion = Boolean((this.config.features?.sideChatPromotion ?? true)
             && sourceRecord.thread.ephemeral
             && sourceRecord.thread.threadSource === "user"
@@ -1149,9 +1187,8 @@ export class ClaudeService {
         if (sourceRecord.thread.ephemeral && !sidePromotion) {
             throw invalidParams("Forking this ephemeral Claude source thread is not supported.");
         }
-        const modelPickerId = params.model ?? sourceRecord.modelPickerId;
-        const claudeModelValue = resolveClaudeModel(this.config, modelPickerId);
-        if (!claudeModelValue)
+        const requestedModel = params.model ?? sourceRecord.modelPickerId;
+        if (!resolveClaudeModel(this.config, requestedModel))
             throw invalidParams("Cannot fork a Claude thread to a Codex model.");
         const activeSideFork = Boolean(params.ephemeral === true && params.excludeTurns === true
             && params.threadSource === "user" && !params.lastTurnId && !params.beforeTurnId);
@@ -1195,8 +1232,10 @@ export class ClaudeService {
         const sourceBoundaries = source.boundaries.filter((entry) => stableSelectedIds.has(entry.turnId));
         const revisionTurns = sourceTurns.filter((turn) => stableSelectedIds.has(turn.id));
         const revision = branchRevision(sourceRecord, sourceBoundaries, revisionTurns);
-        const serviceTier = normalizeClaudeServiceTier(this.config, modelPickerId, params.serviceTier === undefined ? sourceRecord.serviceTier : params.serviceTier);
-        await this.validateModelSettings(modelPickerId, sourceRecord.reasoningEffort, serviceTier);
+        const requestedServiceTier = normalizeClaudeServiceTier(this.config, requestedModel, params.serviceTier === undefined ? sourceRecord.serviceTier : params.serviceTier);
+        const { modelPickerId, claudeModelValue, reasoningEffort, serviceTier } = await this.resolveModelSettings(requestedModel, sourceRecord.reasoningEffort, requestedServiceTier);
+        if (serviceTier !== requestedServiceTier)
+            throw invalidParams(`Claude model '${requestedModel}' does not support the fast service tier.`);
         const boundary = selectedBoundary?.messageUuid ?? sourceBoundaries.at(-1)?.messageUuid;
         const branch = boundary
             ? await this.transcripts.forkWithProvenance(sourceRecord.claudeSessionId, boundary, sourceRecord.thread.cwd, sourceBoundaries.map((entry) => entry.messageUuid), boundaryCorrelations(this.store, sourceRecord, sourceBoundaries))
@@ -1220,9 +1259,11 @@ export class ClaudeService {
         });
         const threadId = uuidv7();
         const thread = {
-            ...sourceRecord.thread, id: threadId, ephemeral: params.ephemeral ?? false, isPinned: false,
+            ...sourceRecord.thread, id: threadId, ephemeral: params.ephemeral ?? false,
+            section: null, sectionEnteredAt: null, projectId: null,
             sessionId: threadId, forkedFromId: visibleForkedFromId,
-            cwd, modelProvider: "claude", createdAt, updatedAt: createdAt, recencyAt: createdAt,
+            cwd, modelProvider: "claude", model: modelPickerId, reasoningEffort,
+            createdAt, updatedAt: createdAt, recencyAt: createdAt,
             status: params.ephemeral ? { type: "idle" } : { type: "notLoaded" },
             canAcceptDirectInput: true,
             name: params.ephemeral
@@ -1233,7 +1274,7 @@ export class ClaudeService {
         const copiedTurns = sourceTurns.map((turn) => forkProjection(turn, thread.id));
         const record = {
             ...sourceRecord, thread, runtimeWorkspaceRoots,
-            claudeSessionId: branch.sessionId, modelPickerId, claudeModelValue, serviceTier,
+            claudeSessionId: branch.sessionId, modelPickerId, claudeModelValue, serviceTier, reasoningEffort,
             approvalPolicy: params.approvalPolicy ?? sourceRecord.approvalPolicy,
             approvalsReviewer: approvalsReviewer(params.approvalsReviewer, sourceRecord.approvalsReviewer),
             sandboxPolicy: params.permissions
@@ -1281,21 +1322,43 @@ export class ClaudeService {
         return threadResponse(responseRecord, !params.excludeTurns);
     }
     async rollbackThread(params) {
-        this.requireIndependentThread(params.threadId, "roll back");
-        const source = await this.sessions.submit(params.threadId, { type: "snapshotBranch" });
-        const sourceRecord = source.record;
-        if (sourceRecord.thread.ephemeral)
-            throw invalidParams("Rolling back an ephemeral Claude thread is not supported.");
+        const source = await this.truncationSource(params.threadId, "roll back");
+        if (source.record.thread.historyMode === "paginated")
+            throw invalidRequest("paginated threads do not support thread/rollback");
         if (!Number.isInteger(params.numTurns) || params.numTurns < 1)
             throw invalidParams("numTurns must be at least 1.");
-        if (params.numTurns > sourceRecord.thread.turns.length)
+        if (params.numTurns > source.record.thread.turns.length)
             throw invalidParams("Cannot remove more turns than the Claude thread contains.");
-        const sourceSession = await this.sessions.getOrCreate(params.threadId);
-        if ((await sourceSession.runtimeInspection())?.quiescent === false)
-            throw invalidParams("Cannot roll back a Claude thread with an active turn.");
-        const keepCount = sourceRecord.thread.turns.length - params.numTurns;
-        const retained = sourceRecord.thread.turns.slice(0, keepCount);
-        const retainedIds = new Set(retained.map((turn) => turn.id));
+        const committed = await this.truncateThread(source, source.record.thread.turns.length - params.numTurns);
+        return { thread: committed.thread };
+    }
+    /** `thread/revert`: drops `beforeTurnId` and every later turn; the App hydrates retained history via the cursors. */
+    async revertThread(params) {
+        const source = await this.truncationSource(params.threadId, "revert");
+        const keepCount = source.record.thread.turns.findIndex((turn) => turn.id === params.beforeTurnId);
+        if (keepCount === -1)
+            throw invalidParams(`Unknown Claude turn '${params.beforeTurnId}'.`);
+        const retained = (await this.truncateThread(source, keepCount)).thread;
+        return {
+            thread: { ...retained, turns: [] },
+            ...historyCursors(retained.turns),
+        };
+    }
+    async truncationSource(threadId, verb) {
+        this.requireIndependentThread(threadId, verb);
+        const snapshot = await this.sessions.submit(threadId, { type: "snapshotBranch" });
+        if (snapshot.record.thread.ephemeral)
+            throw invalidParams(`Cannot ${verb} an ephemeral Claude thread.`);
+        const session = await this.sessions.getOrCreate(threadId);
+        if ((await session.runtimeInspection())?.quiescent === false)
+            throw invalidParams(`Cannot ${verb} a Claude thread with an active turn.`);
+        return { ...snapshot, session };
+    }
+    /** Keeps the first `keepCount` turns by forking the transcript at the last retained provider boundary. */
+    async truncateThread(source, keepCount) {
+        const sourceRecord = source.record;
+        const threadId = sourceRecord.thread.id;
+        const retainedIds = new Set(sourceRecord.thread.turns.slice(0, keepCount).map((turn) => turn.id));
         const sourceBoundaries = source.boundaries.filter((entry) => retainedIds.has(entry.turnId));
         const boundary = sourceBoundaries.at(-1)?.messageUuid;
         const branch = boundary
@@ -1303,7 +1366,7 @@ export class ClaudeService {
             : { sessionId: uuidv7(), uuidMap: new Map() };
         let committed;
         try {
-            committed = await this.sessions.submit(params.threadId, {
+            committed = await this.sessions.submit(threadId, {
                 type: "commitRollback", expectedRevision: source.revision, replacementSessionId: branch.sessionId,
                 keepCount, sourceBoundaries, uuidMap: [...branch.uuidMap],
             });
@@ -1312,18 +1375,118 @@ export class ClaudeService {
             await this.transcripts.delete(branch.sessionId, sourceRecord.thread.cwd).catch(() => undefined);
             throw error;
         }
-        if (sourceSession.isLoaded) {
-            await sourceSession.retireRuntimeSilently().catch((error) => {
-                this.logger.warn("claude.rollback.old-runtime-retire-failed", { threadId: params.threadId, error: String(error) });
+        if (source.session.isLoaded) {
+            await source.session.retireRuntimeSilently().catch((error) => {
+                this.logger.warn("claude.rollback.old-runtime-retire-failed", { threadId, error: String(error) });
             });
         }
-        await this.transcripts.delete(sourceRecord.claudeSessionId, sourceRecord.thread.cwd).catch((error) => this.logger.warn("claude.rollback.old-session-delete-failed", { threadId: params.threadId, error: String(error) }));
-        return { thread: committed.thread };
+        await this.transcripts.delete(sourceRecord.claudeSessionId, sourceRecord.thread.cwd).catch((error) => this.logger.warn("claude.rollback.old-session-delete-failed", { threadId, error: String(error) }));
+        return committed;
     }
     prepareGoalSet(params) {
         this.requireIndependentThread(params.threadId, "set a goal on");
         return this.sessions.submit(params.threadId, { type: "goal", command: { kind: "prepareSet", params } }).then((mutation) => this.goalHandle(params.threadId, mutation));
     }
+    async addQueuedSubmission(params) {
+        this.requireIndependentThread(params.threadId, "queue a submission in");
+        const queuedSubmission = await this.sessions.submit(params.threadId, {
+            type: "queue",
+            command: { kind: "add", input: params.input, clientUserMessageId: params.clientUserMessageId },
+        });
+        return { response: { queuedSubmission }, after: () => this.drainQueue(params.threadId) };
+    }
+    /** Offset pagination over the durable per-thread queue; the cursor is the base-10 offset, as in stock. */
+    listQueue(params) {
+        this.requireRecord(params.threadId, false);
+        const cursor = params.cursor ?? null;
+        if (cursor !== null && !/^\d+$/u.test(cursor))
+            throw invalidRequest(`invalid queue pagination cursor: ${cursor}`);
+        const offset = cursor === null ? 0 : Number(cursor);
+        const limit = Math.min(Math.max(params.limit ?? 25, 1), 100);
+        const queue = this.store.listQueuedSubmissions(params.threadId);
+        return {
+            data: queue.slice(offset, offset + limit),
+            nextCursor: offset + limit < queue.length ? String(offset + limit) : null,
+        };
+    }
+    async updateQueuedSubmission(params) {
+        this.requireIndependentThread(params.threadId, "update a queued submission in");
+        const queuedSubmission = await this.sessions.submit(params.threadId, {
+            type: "queue",
+            command: { kind: "update", queuedSubmissionId: params.queuedSubmissionId, input: params.input },
+        });
+        return { queuedSubmission };
+    }
+    async deleteQueuedSubmission(params) {
+        this.requireIndependentThread(params.threadId, "delete a queued submission from");
+        const deleted = await this.sessions.submit(params.threadId, {
+            type: "queue", command: { kind: "delete", queuedSubmissionId: params.queuedSubmissionId },
+        });
+        return { deleted };
+    }
+    async reorderQueue(params) {
+        this.requireIndependentThread(params.threadId, "reorder the queue of");
+        await this.sessions.submit(params.threadId, {
+            type: "queue", command: { kind: "reorder", queuedSubmissionIds: params.queuedSubmissionIds },
+        });
+        return {};
+    }
+    async prepareQueueStart(params) {
+        this.requireIndependentThread(params.threadId, "start a queued submission in");
+        const entry = await this.sessions.submit(params.threadId, {
+            type: "queue",
+            command: {
+                kind: "take",
+                manual: true,
+                ...(params.queuedSubmissionId == null ? {} : { queuedSubmissionId: params.queuedSubmissionId }),
+            },
+        });
+        return this.startQueuedSubmission(params.threadId, entry);
+    }
+    async startQueuedSubmission(threadId, entry) {
+        try {
+            return await this.prepareTurn({ threadId, input: entry.input, clientUserMessageId: entry.clientUserMessageId });
+        }
+        catch (error) {
+            await this.sessions.submit(threadId, { type: "queue", command: { kind: "restore", entry } });
+            throw error;
+        }
+    }
+    /** Starts the head of the queue when the thread is idle and its last turn was not interrupted. */
+    async drainQueue(threadId) {
+        if (this.closing || this.store.listQueuedSubmissions(threadId).length === 0)
+            return;
+        const entry = await this.sessions.submit(threadId, {
+            type: "queue", command: { kind: "take", manual: false },
+        });
+        if (!entry)
+            return;
+        let prepared;
+        try {
+            prepared = await this.startQueuedSubmission(threadId, entry);
+        }
+        catch (error) {
+            this.logger[error instanceof ActiveClaudeTurnError ? "info" : "warn"]("claude.queue.drain-skipped", {
+                threadId, queuedSubmissionId: entry.id, error: String(error),
+            });
+            return;
+        }
+        await prepared.announce();
+        prepared.start();
+    }
+    scheduleQueueDrain(threadId) {
+        queueMicrotask(() => {
+            void this.drainQueue(threadId).catch((error) => {
+                this.logger.warn("claude.queue.drain-failed", { threadId, error: String(error) });
+            });
+        });
+    }
+    onSessionLifecycle(threadId, update) {
+        if (update.completed && update.completed.turn.status !== "interrupted")
+            this.queueDrainPending.add(threadId);
+        if (update.quiescent && this.queueDrainPending.delete(threadId))
+            this.scheduleQueueDrain(threadId);
+    }
     async getGoal(threadId) {
         if (this.requireRecord(threadId, false).thread.parentThreadId)
             return { goal: null };
@@ -1637,7 +1800,9 @@ export class ClaudeService {
         if (!native)
             return {
                 ...record.thread,
-                isPinned: record.thread.isPinned ?? false,
+                section: record.thread.section ?? null,
+                sectionEnteredAt: record.thread.sectionEnteredAt ?? null,
+                projectId: record.thread.projectId ?? null,
                 canAcceptDirectInput: record.thread.parentThreadId ? false : true,
             };
         const createdAt = native.createdAt === undefined
@@ -1646,7 +1811,9 @@ export class ClaudeService {
         const updatedAt = Math.floor(native.lastModified / 1_000);
         return {
             ...record.thread,
-            isPinned: record.thread.isPinned ?? false,
+            section: record.thread.section ?? null,
+            sectionEnteredAt: record.thread.sectionEnteredAt ?? null,
+            projectId: record.thread.projectId ?? null,
             canAcceptDirectInput: record.thread.parentThreadId ? false : true,
             name: record.thread.name || native.customTitle || native.summary,
             preview: native.firstPrompt ?? record.thread.preview,
@@ -1704,17 +1871,15 @@ export class ClaudeService {
         return undefined;
     }
     async newThreadRecord(params, settings) {
-        const modelPickerId = params.model;
-        const claudeModelValue = modelPickerId && resolveClaudeModel(this.config, modelPickerId);
-        if (!modelPickerId || !claudeModelValue)
+        const requestedModel = params.model;
+        if (!requestedModel || !resolveClaudeModel(this.config, requestedModel))
             throw invalidParams("Claude thread requires a configured Claude model or alias.");
         if (params.permissions && params.sandbox)
             throw invalidParams("Claude thread start cannot combine permissions with sandbox.");
-        const requestedServiceTier = normalizeClaudeServiceTier(this.config, modelPickerId, params.serviceTier);
+        const requestedServiceTier = normalizeClaudeServiceTier(this.config, requestedModel, params.serviceTier);
         if (requestedServiceTier !== null && requestedServiceTier !== "default" && requestedServiceTier !== "fast")
             throw invalidParams(`Unsupported Claude service tier '${requestedServiceTier}'.`);
-        const reasoningEffort = settings?.effort ?? null;
-        const serviceTier = await this.validatedServiceTier(modelPickerId, reasoningEffort, requestedServiceTier);
+        const { modelPickerId, claudeModelValue, reasoningEffort, serviceTier } = await this.resolveModelSettings(requestedModel, settings?.effort ?? null, requestedServiceTier);
         const createdAt = nowSeconds();
         const workspace = workspaceSelection(params);
         const { cwd, runtimeWorkspaceRoots } = workspace;
@@ -1727,9 +1892,11 @@ export class ClaudeService {
                 parentThreadId: null,
                 preview: "",
                 ephemeral: params.ephemeral ?? false,
-                isPinned: false,
-                historyMode: params.historyMode ?? "legacy",
-                modelProvider: "claude",
+                section: null,
+                sectionEnteredAt: null,
+                projectId: null,
+                historyMode: params.historyMode ?? (params.ephemeral ? "legacy" : "paginated"),
+                modelProvider: "claude", model: modelPickerId, reasoningEffort,
                 createdAt,
                 updatedAt: createdAt,
                 recencyAt: createdAt,
@@ -1803,11 +1970,10 @@ export class ClaudeService {
         const session = await this.sessions.getOrCreate(params.threadId);
         for (;;) {
             const before = await this.sessions.submit(params.threadId, { type: "readThread", includeTurns: false });
-            const modelPickerId = params.model ?? before.modelPickerId;
-            const claudeModelValue = resolveClaudeModel(this.config, modelPickerId);
-            if (!claudeModelValue)
+            const requestedModel = params.model ?? before.modelPickerId;
+            if (!resolveClaudeModel(this.config, requestedModel))
                 throw invalidParams("Cannot switch a Claude thread to a Codex model.");
-            const requestedServiceTier = normalizeClaudeServiceTier(this.config, modelPickerId, params.serviceTier === undefined ? before.serviceTier : params.serviceTier);
+            const requestedServiceTier = normalizeClaudeServiceTier(this.config, requestedModel, params.serviceTier === undefined ? before.serviceTier : params.serviceTier);
             if (requestedServiceTier !== null && requestedServiceTier !== "default" && requestedServiceTier !== "fast")
                 throw invalidParams(`Unsupported Claude service tier '${requestedServiceTier}'.`);
             const { cwd, runtimeWorkspaceRoots } = workspaceSelection(params, {
@@ -1817,8 +1983,7 @@ export class ClaudeService {
             const workspaceChanged = cwd !== before.thread.cwd
                 || runtimeWorkspaceRoots.length !== storedWorkspaceRoots(before).length
                 || runtimeWorkspaceRoots.some((root, index) => root !== storedWorkspaceRoots(before)[index]);
-            const reasoningEffort = params.effort === undefined ? before.reasoningEffort : params.effort;
-            const serviceTier = await this.validatedServiceTier(modelPickerId, reasoningEffort, requestedServiceTier);
+            const { modelPickerId, claudeModelValue, reasoningEffort, serviceTier } = await this.resolveModelSettings(requestedModel, params.effort === undefined ? before.reasoningEffort : params.effort, requestedServiceTier, params.effort !== undefined);
             syncCanonicalSettings = requestedServiceTier === "fast" && serviceTier !== "fast";
             const collaborationMode = params.collaborationMode === undefined
                 ? before.collaborationMode
@@ -1873,24 +2038,30 @@ export class ClaudeService {
             }
         }
     }
-    async validatedServiceTier(modelId, effort, serviceTier) {
+    /**
+     * Resolves requested model settings against the account catalog. A model id the catalog no longer
+     * lists is migrated onto its closest current entry instead of failing the request, and an effort the
+     * target model does not support is coerced to that model's default unless it was requested explicitly.
+     */
+    async resolveModelSettings(modelPickerId, effort, serviceTier, explicitEffort = false) {
+        const claudeModelValue = resolveClaudeModel(this.config, modelPickerId);
         if (!this.modelCatalog)
-            return serviceTier;
-        const catalogId = claudeCatalogId(this.config, modelId);
-        const model = (await this.modelCatalog.list()).find((candidate) => candidate.id === catalogId);
-        if (!model)
-            throw invalidParams(`Claude model '${modelId}' is not present in the current account catalog.`);
-        if (effort && !model.supportedReasoningEfforts.some((level) => level.reasoningEffort === effort)) {
-            throw invalidParams(`Claude model '${modelId}' does not support effort '${effort}'.`);
-        }
-        return serviceTier === "fast" && !model.serviceTiers.some((tier) => tier.id === "fast")
-            ? null
-            : serviceTier;
-    }
-    async validateModelSettings(modelId, effort, serviceTier) {
-        if (await this.validatedServiceTier(modelId, effort, serviceTier) !== serviceTier) {
-            throw invalidParams(`Claude model '${modelId}' does not support the fast service tier.`);
-        }
+            return { modelPickerId, claudeModelValue, reasoningEffort: effort, serviceTier };
+        const lookup = this.catalogLookup(await this.modelCatalog.list(), claudeModelValue);
+        const model = lookup?.model;
+        if (!lookup || !model)
+            throw invalidParams(`Claude model '${modelPickerId}' is not present in the current account catalog.`);
+        const selection = this.catalogSelection(modelPickerId, claudeModelValue, lookup);
+        const effortSupported = !effort || model.supportedReasoningEfforts.some((level) => level.reasoningEffort === effort);
+        if (!effortSupported && explicitEffort && selection.modelPickerId === modelPickerId)
+            throw invalidParams(`Claude model '${modelPickerId}' does not support effort '${effort}'.`);
+        if (!effortSupported)
+            this.logger.warn("claude.effort.coerced", { model: model.id, from: effort, to: model.defaultReasoningEffort });
+        return {
+            ...selection,
+            reasoningEffort: effortSupported ? effort : model.supportedReasoningEfforts.length ? model.defaultReasoningEffort : null,
+            serviceTier: serviceTier === "fast" && !model.serviceTiers.some((tier) => tier.id === "fast") ? null : serviceTier,
+        };
     }
     async readStandaloneRateLimitStatus() {
         const abort = new AbortController();