@gkorepanov/ccodex 0.4.19 → 0.4.23

package/dist/handoff/service.js

@@ -1,7 +1,9 @@
 import { DEFAULT_RENAME_PROMPT } from "../config/config.js";
+import { findStockSection } from "../gateway/stockRpc.js";
 import { projectItemIds, projectRpcToBackendThread, projectRpcToPublicThread, } from "../gateway/logicalThreadProjection.js";
-import { invalidParams } from "../protocol/errors.js";
-import { paginateTurns } from "../protocol/turnPagination.js";
+import { invalidParams, invalidRequest } from "../protocol/errors.js";
+import { historyCursors, paginateItems, paginateTurns } from "../protocol/turnPagination.js";
+import { searchTurnOccurrences } from "../protocol/search.js";
 import { filterSortThreads } from "../store/threadFilter.js";
 import { v7 as uuidv7 } from "uuid";
 import { stockSwitchThreadSource, ProviderEpochs, } from "./providerEpochs.js";
@@ -166,23 +168,25 @@ function stagedSettings(base, pending) {
 function pageTurns(turns, params) {
     return paginateTurns(turns, params, ["hyb-overlay-turn:", "hyb-turn:"]);
 }
+/** Full stock history without the deprecated paginated `includeTurns` hydration: page `thread/turns/list` instead. */
+async function readStockThread(stock, threadId) {
+    const { thread } = await stock.request("thread/read", { threadId, includeTurns: false });
+    if (thread.historyMode !== "paginated") {
+        return (await stock.request("thread/read", { threadId, includeTurns: true })).thread;
+    }
+    const turns = [];
+    let cursor = null;
+    do {
+        const page = await stock.request("thread/turns/list", {
+            threadId, cursor, limit: 100, sortDirection: "asc", itemsView: "full",
+        });
+        turns.push(...page.data);
+        cursor = page.nextCursor;
+    } while (cursor);
+    return { ...thread, turns };
+}
 function pageItems(turns, params) {
-    if (params.cursor && !params.cursor.startsWith("hyb-overlay-item:"))
-        throw invalidParams("Invalid handoff item cursor.");
-    const offset = params.cursor ? Number(params.cursor.slice("hyb-overlay-item:".length)) : 0;
-    if (!Number.isInteger(offset) || offset < 0)
-        throw invalidParams("Invalid handoff item cursor.");
-    const items = turns.flatMap((turn) => params.turnId && turn.id !== params.turnId
-        ? []
-        : turn.items.map((item) => ({ turnId: turn.id, item })));
-    const ordered = params.sortDirection === "desc" ? [...items].reverse() : items;
-    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-overlay-item:${offset + data.length}` : null,
-        backwardsCursor: data.length > 0 ? `hyb-overlay-item:${Math.max(0, offset - limit)}` : null,
-    };
+    return paginateItems(turns, params, ["hyb-overlay-item:"]);
 }
 function messageThreadId(message) {
     if (!message.params || typeof message.params !== "object")
@@ -217,7 +221,7 @@ export class CrossProviderForks {
     titleTurns = new Map();
     stockServerRequests = new Map();
     stockServerRequestAliases = new Map();
-    recentDurableProviders = new Map();
+    recentDurableThreads = new Map();
     adminTails = new Map();
     lineage;
     legacyMirror;
@@ -236,6 +240,9 @@ export class CrossProviderForks {
     }
     pending(threadId) { return this.store.getPending(threadId); }
     logical(threadId) { return this.epochs.resolve(threadId); }
+    currentBackendId(publicThreadId) {
+        return this.epochs.resolve(publicThreadId)?.epoch.backendThreadId;
+    }
     hiddenBackendIds(provider) { return this.epochs.hiddenBackendIds(provider); }
     catalogTombstones() { return this.store.remoteCatalogTombstones(); }
     async sideSnapshot(params, targetThreadId) {
@@ -398,6 +405,16 @@ export class CrossProviderForks {
                 return { provider: resolved.epoch.provider, result: {} };
             }
         }
+        if (method === "thread/searchOccurrences") {
+            const stock = this.daemonStock ?? clientStock;
+            const turns = resolved.epoch.backendThreadId.startsWith("ccodex-provisional:")
+                ? this.store.listLogicalTurns(publicThreadId).map((value) => value.turn)
+                : await this.visibleTurns(publicThreadId, await this.currentBackendTurns(resolved, stock), stock);
+            return {
+                provider: resolved.epoch.provider,
+                result: searchTurnOccurrences(publicThreadId, turns, publicParams),
+            };
+        }
         if (resolved.epoch.backendThreadId.startsWith("ccodex-provisional:")) {
             return this.requestProvisionalLogical(method, publicParams, resolved);
         }
@@ -407,16 +424,10 @@ export class CrossProviderForks {
                 const result = await this.withAdminLock(publicThreadId, () => stock.request(method, params));
                 return { provider: "stock", result: projectRpcToPublicThread({ result }, owner).result };
             }
-            if (method === "thread/metadata/update") {
-                const metadata = publicParams;
-                const result = await this.withAdminLock(publicThreadId, async () => {
-                    const response = await stock.request(method, params);
-                    if (metadata.isPinned !== undefined && metadata.isPinned !== null
-                        && !this.lineage.updateTaskPinned(publicThreadId, metadata.isPinned)) {
-                        throw new Error(`Unknown logical thread '${publicThreadId}'.`);
-                    }
-                    return response;
-                });
+            if (method === "thread/metadata/update" || method === "thread/section/move") {
+                // Section membership lives on the current backend thread; it is not
+                // mirrored across provider switches.
+                const result = await this.withAdminLock(publicThreadId, () => stock.request(method, params));
                 return { provider: "stock", result: projectRpcToPublicThread({ result }, owner).result };
             }
             if (method === "thread/read" || method === "thread/resume") {
@@ -425,33 +436,25 @@ export class CrossProviderForks {
                 const includeTurns = resume
                     ? !resume.excludeTurns
                     : params.includeTurns ?? false;
-                const backendTurns = resume?.initialTurnsPage && !includeTurns
-                    ? (await stock.request("thread/read", {
-                        threadId: resolved.epoch.backendThreadId,
-                        includeTurns: true,
-                    })).thread.turns
+                const backendTurns = resume && !includeTurns
+                    ? (await readStockThread(stock, resolved.epoch.backendThreadId)).turns
                     : result.thread.turns;
+                const visible = resume ? await this.visibleTurns(publicThreadId, backendTurns, stock) : [];
                 const initialTurnsPage = resume?.initialTurnsPage
-                    ? pageTurns(await this.visibleTurns(publicThreadId, backendTurns, stock), {
-                        threadId: publicThreadId,
-                        ...resume.initialTurnsPage,
-                    })
-                    : "initialTurnsPage" in result ? result.initialTurnsPage : undefined;
+                    ? pageTurns(visible, { threadId: publicThreadId, ...resume.initialTurnsPage })
+                    : undefined;
                 return {
                     provider: "stock",
                     result: {
                         ...result,
                         thread: this.epochs.projectThread(publicThreadId, projectItemIds(result.thread, resolved.epoch.id), includeTurns, includeTurns ? (await this.historicalTurns(publicThreadId, stock)).map((entry) => entry.turn) : []),
-                        ...(resume ? { initialTurnsPage } : {}),
+                        ...(resume ? { initialTurnsPage, ...historyCursors(visible) } : {}),
                     },
                 };
             }
             if (method === "thread/turns/list" || method === "thread/items/list") {
-                const read = await stock.request("thread/read", {
-                    threadId: resolved.epoch.backendThreadId,
-                    includeTurns: true,
-                });
-                const turns = await this.visibleTurns(publicThreadId, read.thread.turns, stock);
+                const read = await readStockThread(stock, resolved.epoch.backendThreadId);
+                const turns = await this.visibleTurns(publicThreadId, read.turns, stock);
                 return {
                     provider: "stock",
                     result: method === "thread/turns/list"
@@ -483,19 +486,18 @@ export class CrossProviderForks {
             const thread = this.epochs.projectThread(publicThreadId, projectItemIds(response.thread, resolved.epoch.id), !resume.excludeTurns, !resume.excludeTurns
                 ? (await this.historicalTurns(publicThreadId, this.daemonStock ?? clientStock)).map((entry) => entry.turn)
                 : []);
-            const backendTurns = resume.initialTurnsPage && resume.excludeTurns
+            const backendTurns = resume.excludeTurns
                 ? this.claude.readThread(threadId, true).thread.turns
                 : response.thread.turns;
+            const visible = await this.visibleTurns(publicThreadId, backendTurns, this.daemonStock ?? clientStock);
             return {
                 provider: "claude",
                 result: {
                     ...response,
                     thread,
+                    ...historyCursors(visible),
                     ...(resume.initialTurnsPage ? {
-                        initialTurnsPage: pageTurns(await this.visibleTurns(publicThreadId, backendTurns, this.daemonStock ?? clientStock), {
-                            threadId: publicThreadId,
-                            ...resume.initialTurnsPage,
-                        }),
+                        initialTurnsPage: pageTurns(visible, { threadId: publicThreadId, ...resume.initialTurnsPage }),
                     } : {}),
                 },
                 after: async () => prepared.notifyGoalSnapshot((event, eventParams) => {
@@ -537,19 +539,19 @@ export class CrossProviderForks {
             }
         }
         if (method === "thread/metadata/update") {
-            const metadata = publicParams;
             return {
                 provider: "claude",
-                result: await this.withAdminLock(publicThreadId, async () => {
-                    const result = await this.claude.updateThreadMetadata(params);
-                    if (metadata.isPinned !== undefined && metadata.isPinned !== null
-                        && !this.lineage.updateTaskPinned(publicThreadId, metadata.isPinned)) {
-                        throw new Error(`Unknown logical thread '${publicThreadId}'.`);
-                    }
-                    return result;
-                }),
+                result: await this.withAdminLock(publicThreadId, () => this.claude.updateThreadMetadata(params)),
             };
         }
+        if (method === "thread/section/move") {
+            const move = params;
+            const section = move.sectionId === null
+                ? null
+                : await findStockSection(this.daemonStock ?? clientStock, move.sectionId);
+            await this.withAdminLock(publicThreadId, () => this.claude.setThreadSection(move.threadId, section));
+            return { provider: "claude", result: {} };
+        }
         if (method === "thread/archive") {
             const buffer = this.subscriptions?.bufferLifecycle(threadId, ["thread/archived"]);
             try {
@@ -626,6 +628,41 @@ export class CrossProviderForks {
         if (method === "turn/steer") {
             return { provider: "claude", result: await this.claude.steerTurn(params) };
         }
+        if (method === "thread/queue/list") {
+            return { provider: "claude", result: this.claude.listQueue(params) };
+        }
+        if (method === "app/list" || method === "mcpServerStatus/list") {
+            return { provider: "claude", result: { data: [], nextCursor: null } };
+        }
+        if (method === "app/installed")
+            return { provider: "claude", result: { apps: [] } };
+        if (method === "thread/queue/add") {
+            const prepared = await this.claude.addQueuedSubmission(params);
+            return { provider: "claude", result: prepared.response, after: prepared.after };
+        }
+        if (method === "thread/queue/update") {
+            return {
+                provider: "claude",
+                result: await this.claude.updateQueuedSubmission(params),
+            };
+        }
+        if (method === "thread/queue/delete") {
+            return {
+                provider: "claude",
+                result: await this.claude.deleteQueuedSubmission(params),
+            };
+        }
+        if (method === "thread/queue/reorder") {
+            return { provider: "claude", result: await this.claude.reorderQueue(params) };
+        }
+        if (method === "thread/queue/start") {
+            const prepared = await this.claude.prepareQueueStart(params);
+            return {
+                provider: "claude",
+                result: prepared.response,
+                after: async () => { await prepared.announce(); prepared.start(); },
+            };
+        }
         throw invalidParams(`Method '${method}' is not implemented for a migrated Claude task yet.`);
     }
     requestProvisionalLogical(method, params, resolved) {
@@ -643,10 +680,12 @@ export class CrossProviderForks {
         }
         if (method === "thread/resume") {
             const settings = resolved.epoch.settings;
+            const resume = params;
             return {
                 provider: resolved.epoch.provider,
                 result: {
-                    thread: thread(!params.excludeTurns),
+                    thread: thread(!resume.excludeTurns),
+                    ...historyCursors(turns),
                     model: resolved.epoch.model,
                     modelProvider: resolved.epoch.provider === "claude" ? "claude" : "openai",
                     serviceTier: typeof settings.serviceTier === "string" ? settings.serviceTier : null,
@@ -660,7 +699,9 @@ export class CrossProviderForks {
                     activePermissionProfile: settings.activePermissionProfile ?? null,
                     reasoningEffort: settings.reasoningEffort ?? settings.effort ?? null,
                     multiAgentMode: settings.multiAgentMode ?? "explicitRequestOnly",
-                    initialTurnsPage: null,
+                    initialTurnsPage: resume.initialTurnsPage
+                        ? pageTurns(turns, { threadId: resolved.logical.publicThreadId, ...resume.initialTurnsPage })
+                        : null,
                 },
             };
         }
@@ -695,9 +736,15 @@ export class CrossProviderForks {
         }
         const currentTurns = await this.currentBackendTurns(source, this.daemonStock ?? clientStock);
         const visible = await this.snapshotTurns(params.threadId, currentTurns, this.daemonStock ?? clientStock);
-        const boundaryIndex = visible.findLastIndex((turn) => turn.turn.status === "completed" && turn.epochId && turn.providerTurnId);
+        const requested = params.lastTurnId ?? params.beforeTurnId;
+        const requestedIndex = requested ? visible.findIndex((turn) => turn.turn.id === requested) : undefined;
+        if (requestedIndex === -1)
+            throw invalidRequest(`turn not found: ${requested}`);
+        const boundaryIndex = requestedIndex === undefined
+            ? visible.findLastIndex((turn) => turn.turn.status === "completed" && turn.epochId && turn.providerTurnId)
+            : params.lastTurnId ? requestedIndex : requestedIndex - 1;
         const boundary = visible[boundaryIndex];
-        if (!boundary?.epochId || !boundary.providerTurnId) {
+        if (!boundary?.epochId || !boundary.providerTurnId || boundary.turn.status !== "completed") {
             throw invalidParams("Cannot fork before the task has a completed provider turn.");
         }
         const selectedBoundary = this.lineage.getEpoch(boundary.epochId);
@@ -801,21 +848,37 @@ export class CrossProviderForks {
             throw error;
         }
     }
-    async rollbackLogicalThread(params, clientStock, connectionId) {
+    rollbackLogicalThread(params, clientStock, connectionId) {
+        if (!Number.isInteger(params.numTurns) || params.numTurns < 0) {
+            throw invalidParams("numTurns must be a non-negative integer.");
+        }
+        return this.truncateLogicalThread(params.threadId, (turns) => turns.length - params.numTurns, clientStock, connectionId);
+    }
+    /** `thread/revert` on a logical thread: drops `beforeTurnId` and later public turns via the rollback path. */
+    async revertLogicalThread(params, clientStock, connectionId) {
+        const { thread } = await this.truncateLogicalThread(params.threadId, (turns) => {
+            const keep = turns.findIndex((entry) => entry.publicTurnId === params.beforeTurnId);
+            if (keep === -1)
+                throw invalidParams(`Unknown turn '${params.beforeTurnId}'.`);
+            return keep;
+        }, clientStock, connectionId);
+        return { thread: { ...thread, turns: [] }, ...historyCursors(thread.turns) };
+    }
+    async truncateLogicalThread(publicThreadId, keepOf, clientStock, connectionId) {
+        const params = { threadId: publicThreadId };
         const selection = this.store.getForkSelection(params.threadId);
         const unresolvedTarget = this.epochs.resolve(params.threadId);
         if (!unresolvedTarget)
             throw invalidParams(`Unknown logical thread '${params.threadId}'.`);
         const target = await this.hydrate(unresolvedTarget, this.daemonStock ?? clientStock);
-        if (!Number.isInteger(params.numTurns) || params.numTurns < 0) {
-            throw invalidParams("numTurns must be a non-negative integer.");
-        }
         const pendingFork = selection?.status === "pending" ? selection : undefined;
-        const currentTurns = await this.currentBackendTurns(target, this.daemonStock ?? clientStock);
+        const backend = await this.backendThread(target, this.daemonStock ?? clientStock);
+        const currentTurns = backend?.turns ?? [];
         const turns = await this.snapshotTurns(params.threadId, currentTurns, this.daemonStock ?? clientStock);
-        const keep = turns.length - params.numTurns;
+        const keep = keepOf(turns);
         if (keep <= 0)
             throw invalidParams("Rollback removed every provider turn.");
+        const numTurns = turns.length - keep;
         const retained = turns.slice(0, keep);
         const boundary = [...retained].reverse().find((turn) => turn.epochId && turn.providerTurnId);
         if (!boundary?.epochId || !boundary.providerTurnId) {
@@ -828,25 +891,10 @@ export class CrossProviderForks {
         }
         const selectedEpoch = await this.hydrateEpoch(selectedBoundary.epochId, this.daemonStock ?? clientStock);
         if (!pendingFork && selectedEpoch.id === target.epoch.id) {
-            if (params.numTurns === 0) {
-                const backend = target.epoch.provider === "claude"
-                    ? this.claude.readThread(target.epoch.backendThreadId, true).thread
-                    : (await clientStock.request("thread/read", {
-                        threadId: target.epoch.backendThreadId,
-                        includeTurns: true,
-                    })).thread;
-                return { thread: this.epochs.projectThread(params.threadId, projectItemIds(backend, target.epoch.id), true, (await this.historicalTurns(params.threadId, this.daemonStock ?? clientStock)).map((entry) => entry.turn)) };
-            }
-            const rolled = target.epoch.provider === "claude"
-                ? await this.claude.rollbackThread({
-                    threadId: target.epoch.backendThreadId,
-                    numTurns: params.numTurns,
-                })
-                : await clientStock.request("thread/rollback", {
-                    threadId: target.epoch.backendThreadId,
-                    numTurns: params.numTurns,
-                });
-            return { thread: this.epochs.projectThread(params.threadId, projectItemIds(rolled.thread, target.epoch.id), true, (await this.historicalTurns(params.threadId, this.daemonStock ?? clientStock)).map((entry) => entry.turn)) };
+            const rolled = numTurns === 0
+                ? backend
+                : await this.truncateBackend(target, backend, turns[keep], numTurns, clientStock);
+            return { thread: this.epochs.projectThread(params.threadId, projectItemIds(rolled, target.epoch.id), true, (await this.historicalTurns(params.threadId, this.daemonStock ?? clientStock)).map((entry) => entry.turn)) };
         }
         let forked;
         let stockBuildOwner;
@@ -1139,10 +1187,7 @@ export class CrossProviderForks {
         if (job.targetBackendThreadId && job.targetProviderTurnId) {
             const target = job.targetProvider === "claude"
                 ? this.claude.readThread(job.targetBackendThreadId, true).thread
-                : (await stock.request("thread/read", {
-                    threadId: job.targetBackendThreadId,
-                    includeTurns: true,
-                })).thread;
+                : await readStockThread(stock, job.targetBackendThreadId);
             if (target.turns.some((turn) => turn.id === job.targetProviderTurnId)) {
                 const material = await this.providerSwitchMaterial(job, stock, `${HANDOFF_DAEMON_CONNECTION_ID}:recovery:${job.id}`);
                 const sealed = await this.finalizeProviderSwitch(job, target, material.targetSettings, material.sourceTurns, stock);
@@ -1274,7 +1319,7 @@ export class CrossProviderForks {
             if (items.length > 0)
                 await stock.request("thread/inject_items", { threadId: created.thread.id, items });
             const threads = this.systemEphemeralThreads.get(connectionId) ?? new Map();
-            threads.set(created.thread.id, { durableProvider: "claude" });
+            threads.set(created.thread.id, { durableProvider: "claude", durableThreadId: params.threadId });
             this.systemEphemeralThreads.set(connectionId, threads);
             return {
                 ...created,
@@ -1322,9 +1367,9 @@ export class CrossProviderForks {
         const directStart = !("threadId" in params);
         if (params.ephemeral !== true)
             return;
-        const durableProvider = "threadId" in params
-            ? this.claude.ownsThread(params.threadId) ? "claude" : "stock"
-            : this.recentDurableProviders.get(connectionId) ?? "stock";
+        const owner = "threadId" in params
+            ? { durableProvider: this.claude.ownsThread(params.threadId) ? "claude" : "stock", durableThreadId: params.threadId }
+            : this.recentDurableThreads.get(connectionId) ?? { durableProvider: "stock" };
         const candidates = directStart && params.threadSource !== "system" && params.threadSource !== "user"
             ? this.directTitleCandidates
             : params.threadSource === "system" ? this.systemEphemeralThreads : undefined;
@@ -1333,11 +1378,11 @@ export class CrossProviderForks {
         const threads = candidates.get(connectionId) ?? new Map();
         if (threads.size >= 64 && !threads.has(threadId))
             threads.delete(threads.keys().next().value);
-        threads.set(threadId, { durableProvider });
+        threads.set(threadId, owner);
         candidates.set(connectionId, threads);
     }
-    observeDurableThread(connectionId, provider) {
-        this.recentDurableProviders.set(connectionId, provider);
+    observeDurableThread(connectionId, provider, threadId) {
+        this.recentDurableThreads.set(connectionId, { durableProvider: provider, durableThreadId: threadId });
     }
     observeDurableTurn(connectionId, params) {
         if (this.systemEphemeralThreads.get(connectionId)?.has(params.threadId)
@@ -1348,7 +1393,9 @@ export class CrossProviderForks {
             return;
         const durableProvider = this.claude.ownsThread(params.threadId) ? "claude" : "stock";
         const turn = [...this.titleTurns.values()].reverse()
-            .find((candidate) => candidate.connectionId === connectionId && candidate.userPrompt.trim() === text);
+            .find((candidate) => candidate.connectionId === connectionId
+            && (!candidate.durableThreadId || candidate.durableThreadId === params.threadId)
+            && candidate.userPrompt.trim() === text);
         if (turn)
             turn.durableProvider = durableProvider;
     }
@@ -1373,6 +1420,7 @@ export class CrossProviderForks {
             return params;
         const turn = {
             durableProvider: owner.durableProvider,
+            durableThreadId: owner.durableThreadId,
             connectionId,
             userPrompt: prompt.userPrompt,
             outputSchema: prompt.outputSchema,
@@ -1383,6 +1431,19 @@ export class CrossProviderForks {
             : item);
         return { ...params, input };
     }
+    async persistGeneratedTitle(message) {
+        if (message.method !== "turn/completed")
+            return;
+        const params = message.params;
+        const title = this.titleTurns.get(params.threadId);
+        if (params.turn.status !== "completed" || title?.durableProvider !== "claude"
+            || !title.durableThreadId || !title.output)
+            return;
+        await this.claude.setGeneratedThreadName({
+            threadId: title.durableThreadId,
+            name: JSON.parse(title.output).title,
+        }, title.userPrompt);
+    }
     rewriteTitleMessages(message) {
         if (!message.params || typeof message.params !== "object")
             return undefined;
@@ -1499,7 +1560,7 @@ export class CrossProviderForks {
         const threads = this.systemEphemeralThreads.get(connectionId) ?? new Map();
         this.systemEphemeralThreads.delete(connectionId);
         this.directTitleCandidates.delete(connectionId);
-        this.recentDurableProviders.delete(connectionId);
+        this.recentDurableThreads.delete(connectionId);
         for (const threadId of threads.keys())
             this.titleTurns.delete(threadId);
         await Promise.allSettled([...threads.keys()].map((threadId) => stock.request("thread/delete", { threadId })));
@@ -1547,6 +1608,7 @@ export class CrossProviderForks {
         const full = await this.fullOverlayTurns(params.threadId, overlay, stock);
         return {
             ...result,
+            ...historyCursors(full),
             thread: this.patchThread(result.thread, overlay, !params.excludeTurns, full),
             initialTurnsPage: params.initialTurnsPage ? pageTurns(full, {
                 threadId: params.threadId,
@@ -1584,10 +1646,10 @@ export class CrossProviderForks {
             }
             else {
                 const [read, resume] = await Promise.all([
-                    stock.request("thread/read", { threadId, includeTurns: true }),
+                    readStockThread(stock, threadId),
                     stock.request("thread/resume", { threadId, excludeTurns: true }),
                 ]);
-                resolved = this.epochs.seed(read.thread, "stock", resume.model, resume);
+                resolved = this.epochs.seed(read, "stock", resume.model, resume);
             }
         }
         if (resolved.epoch.provider !== pending.sourceProvider) {
@@ -1596,17 +1658,32 @@ export class CrossProviderForks {
         this.store.setPending({ ...pending, expectedEpochId: resolved.epoch.id });
         return this.epochs.resolve(threadId);
     }
-    async currentBackendTurns(resolved, stock) {
+    async backendThread(resolved, stock) {
         if (resolved.epoch.backendThreadId.startsWith("ccodex-provisional:"))
-            return [];
-        if (resolved.epoch.provider === "claude") {
-            return this.claude.readThread(resolved.epoch.backendThreadId, true).thread.turns;
+            return undefined;
+        if (resolved.epoch.provider === "claude")
+            return this.claude.readThread(resolved.epoch.backendThreadId, true).thread;
+        return readStockThread(stock, resolved.epoch.backendThreadId);
+    }
+    /** Drops the current epoch's trailing turns: `thread/revert` on paginated backends, `thread/rollback` on legacy ones. */
+    async truncateBackend(target, backend, firstDropped, numTurns, clientStock) {
+        const threadId = target.epoch.backendThreadId;
+        if (backend.historyMode !== "paginated") {
+            const rolled = target.epoch.provider === "claude"
+                ? await this.claude.rollbackThread({ threadId, numTurns })
+                : await clientStock.request("thread/rollback", { threadId, numTurns });
+            return rolled.thread;
         }
-        const read = await stock.request("thread/read", {
-            threadId: resolved.epoch.backendThreadId,
-            includeTurns: true,
-        });
-        return read.thread.turns;
+        if (!firstDropped.providerTurnId)
+            throw invalidParams("Rollback has no provider-backed turn boundary.");
+        const revert = { threadId, beforeTurnId: firstDropped.providerTurnId };
+        const reverted = target.epoch.provider === "claude"
+            ? await this.claude.revertThread(revert)
+            : await clientStock.request("thread/revert", revert);
+        return { ...reverted.thread, turns: backend.turns.slice(0, backend.turns.length - numTurns) };
+    }
+    async currentBackendTurns(resolved, stock) {
+        return (await this.backendThread(resolved, stock))?.turns ?? [];
     }
     async hydrate(resolved, stock) {
         if (resolved.epoch.backendThreadId.startsWith("ccodex-provisional:"))
@@ -1699,10 +1776,7 @@ export class CrossProviderForks {
             if (!turns) {
                 turns = epoch.provider === "claude"
                     ? this.claude.readThread(epoch.backendThreadId, true).thread.turns
-                    : (await stock.request("thread/read", {
-                        threadId: epoch.backendThreadId,
-                        includeTurns: true,
-                    })).thread.turns;
+                    : (await readStockThread(stock, epoch.backendThreadId)).turns;
                 loaded.set(epoch.epochId, turns);
             }
             const start = turns.findIndex((turn) => turn.id === segment.startTurnId);
@@ -1804,19 +1878,16 @@ export class CrossProviderForks {
             };
         }
         const [read, resume] = await Promise.all([
-            stock.request("thread/read", {
-                threadId: resolved.epoch.backendThreadId,
-                includeTurns: true,
-            }),
+            readStockThread(stock, resolved.epoch.backendThreadId),
             stock.request("thread/resume", {
                 threadId: resolved.epoch.backendThreadId,
                 excludeTurns: true,
             }),
         ]);
         return {
-            thread: read.thread,
-            backendTurns: read.thread.turns,
-            turns: await this.visibleTurns(job.publicThreadId, read.thread.turns, stock),
+            thread: read,
+            backendTurns: read.turns,
+            turns: await this.visibleTurns(job.publicThreadId, read.turns, stock),
             settings: resume,
         };
     }
@@ -2151,8 +2222,8 @@ export class CrossProviderForks {
         };
     }
     async fullOverlayTurns(threadId, overlay, stock) {
-        const read = await stock.request("thread/read", { threadId, includeTurns: true });
-        return [...overlay.inheritedTurns, ...read.thread.turns];
+        const read = await readStockThread(stock, threadId);
+        return [...overlay.inheritedTurns, ...read.turns];
     }
 }
 //# sourceMappingURL=service.js.map