@gkorepanov/ccodex 0.4.5 → 0.4.7

package/dist/handoff/service.js

@@ -287,6 +287,13 @@ export class CrossProviderForks {
             await this.deleteLogicalThread(publicThreadId, clientStock);
             return { provider: resolved.epoch.provider, result: {} };
         }
+        if (method === "thread/archive") {
+            this.store.cancelProviderSwitches(publicThreadId, "Task archived.");
+            if (resolved.epoch.backendThreadId.startsWith("ccodex-provisional:")) {
+                await this.deleteLogicalThread(publicThreadId, clientStock);
+                return { provider: resolved.epoch.provider, result: {} };
+            }
+        }
         if (resolved.epoch.backendThreadId.startsWith("ccodex-provisional:")) {
             return this.requestProvisionalLogical(method, publicParams, resolved);
         }
@@ -523,9 +530,12 @@ export class CrossProviderForks {
             this.patchLogicalThread(resolved.logical.publicThreadId, { name: params.name });
             return { provider: resolved.epoch.provider, result: {} };
         }
+        if (method === "thread/goal/get") {
+            return { provider: resolved.epoch.provider, result: { goal: null } };
+        }
         throw invalidParams("This fork is waiting for Codex App to select a completed history boundary.");
     }
-    async forkLogical(params, clientStock) {
+    async forkLogical(params, clientStock, connectionId) {
         const source = this.epochs.resolve(params.threadId);
         if (!source)
             throw invalidParams(`Unknown logical thread '${params.threadId}'.`);
@@ -534,11 +544,54 @@ export class CrossProviderForks {
         }
         const currentTurns = await this.currentBackendTurns(source, this.daemonStock ?? clientStock);
         const visible = this.epochs.snapshotTurns(params.threadId, currentTurns);
+        const boundaryIndex = visible.findLastIndex((turn) => turn.turn.status === "completed" && turn.epochId && turn.providerTurnId);
+        const boundary = visible[boundaryIndex];
+        if (!boundary?.epochId || !boundary.providerTurnId) {
+            throw invalidParams("Cannot fork before the task has a completed provider turn.");
+        }
+        const selectedEpoch = this.store.getEpoch(boundary.epochId);
+        if (!selectedEpoch || !this.store.epochBelongsToLineage(params.threadId, selectedEpoch.id)) {
+            throw invalidParams("Fork boundary is outside the task's provider lineage.");
+        }
         const targetId = uuidv7();
-        const placeholderId = `ccodex-provisional:${uuidv7()}`;
+        let forked;
+        let stockBuildOwner;
+        if (selectedEpoch.provider === "claude") {
+            forked = await this.claude.forkThread({
+                threadId: selectedEpoch.backendThreadId,
+                lastTurnId: boundary.providerTurnId,
+                model: selectedEpoch.model,
+            }, params.threadId);
+        }
+        else {
+            stockBuildOwner = connectionId;
+            if (stockBuildOwner) {
+                if (this.stockTargetBuilds.has(stockBuildOwner)) {
+                    throw new Error("Another stock thread materialization is already active on this connection.");
+                }
+                this.stockTargetBuilds.set(stockBuildOwner, {
+                    awaitingStart: true,
+                    threadIds: new Set(),
+                    messages: [],
+                    expectedForkedFromId: selectedEpoch.backendThreadId,
+                });
+            }
+            try {
+                forked = await clientStock.request("thread/fork", {
+                    threadId: selectedEpoch.backendThreadId,
+                    lastTurnId: boundary.providerTurnId,
+                    model: selectedEpoch.model,
+                });
+            }
+            catch (error) {
+                if (stockBuildOwner)
+                    this.stockTargetBuilds.delete(stockBuildOwner);
+                throw error;
+            }
+        }
         const now = Math.floor(Date.now() / 1_000);
         const thread = {
-            ...source.logical.thread,
+            ...forked.thread,
             id: targetId,
             sessionId: source.logical.thread.sessionId,
             forkedFromId: params.threadId,
@@ -548,67 +601,102 @@ export class CrossProviderForks {
             recencyAt: now,
             status: { type: "notLoaded" },
             name: source.logical.thread.name ? `${source.logical.thread.name} (fork)` : null,
-            turns: visible.map((turn) => turn.turn),
-        };
-        const target = this.store.createLogicalThread({
-            thread,
-            epoch: {
-                id: uuidv7(),
-                provider: source.epoch.provider,
-                backendThreadId: placeholderId,
-                model: source.epoch.model,
-                settings: source.epoch.settings,
-            },
-        });
-        if (visible.length > 0 && !this.store.replaceLogicalTurns(targetId, target.revision, visible)) {
-            throw new Error("Failed to persist provisional logical fork history.");
-        }
-        const provisional = this.epochs.resolve(targetId);
-        if (!this.store.createForkSelection({
-            targetPublicThreadId: targetId,
-            sourcePublicThreadId: params.threadId,
-            provisionalEpochId: provisional.epoch.id,
-        }))
-            throw new Error("Failed to persist logical fork selection.");
-        const settings = source.epoch.settings;
-        const response = {
-            thread: { ...thread, turns: params.excludeTurns ? [] : thread.turns },
-            model: source.epoch.model,
-            modelProvider: source.epoch.provider === "claude" ? "claude" : "openai",
-            serviceTier: typeof settings.serviceTier === "string" ? settings.serviceTier : null,
-            cwd: thread.cwd,
-            runtimeWorkspaceRoots: Array.isArray(settings.runtimeWorkspaceRoots)
-                ? settings.runtimeWorkspaceRoots : [],
-            instructionSources: Array.isArray(settings.instructionSources)
-                ? settings.instructionSources : [],
-            approvalPolicy: (settings.approvalPolicy ?? "on-request"),
-            approvalsReviewer: (settings.approvalsReviewer ?? "user"),
-            sandbox: (settings.sandbox ?? settings.sandboxPolicy ?? { type: "readOnly" }),
-            activePermissionProfile: (settings.activePermissionProfile ?? null),
-            reasoningEffort: (settings.reasoningEffort ?? settings.effort ?? null),
-            multiAgentMode: "explicitRequestOnly",
+            turns: [],
         };
-        this.subscriptions?.emit(targetId, "thread/started", { thread: { ...thread, turns: [] } });
-        return response;
+        try {
+            const target = this.store.createLogicalThread({
+                thread,
+                epoch: {
+                    id: uuidv7(),
+                    provider: selectedEpoch.provider,
+                    backendThreadId: forked.thread.id,
+                    model: selectedEpoch.model,
+                    settings: selectedEpoch.settings,
+                },
+            });
+            const inherited = visible.slice(0, boundaryIndex + 1).filter((turn) => turn.epochId !== selectedEpoch.id);
+            if (inherited.length > 0 && !this.store.replaceLogicalTurns(targetId, target.revision, inherited)) {
+                throw new Error("Failed to persist logical fork history.");
+            }
+            this.subscriptions?.aliasThread(forked.thread.id, targetId);
+            if (stockBuildOwner)
+                this.stockTargetBuilds.delete(stockBuildOwner);
+            if (selectedEpoch.provider === "claude") {
+                await this.claude.announceThread(forked.thread);
+            }
+            else {
+                this.subscriptions?.emitPublic(targetId, "thread/started", {
+                    thread: this.epochs.projectThread(targetId, forked.thread, false),
+                });
+            }
+            const settings = selectedEpoch.settings;
+            return {
+                ...forked,
+                thread: this.epochs.projectThread(targetId, forked.thread, !params.excludeTurns),
+                model: selectedEpoch.model,
+                modelProvider: selectedEpoch.provider === "claude" ? "claude" : "openai",
+                serviceTier: typeof settings.serviceTier === "string" ? settings.serviceTier : null,
+            };
+        }
+        catch (error) {
+            if (stockBuildOwner)
+                this.stockTargetBuilds.delete(stockBuildOwner);
+            this.store.deleteLogicalThread(targetId);
+            if (!forked?.thread.id)
+                throw error;
+            if (selectedEpoch.provider === "claude") {
+                await this.claude.deleteThread(forked.thread.id).catch(() => undefined);
+            }
+            else {
+                await clientStock.request("thread/delete", { threadId: forked.thread.id }).catch(() => undefined);
+            }
+            throw error;
+        }
     }
-    async rollbackLogicalFork(params, clientStock, connectionId) {
+    async rollbackLogicalThread(params, clientStock, connectionId) {
         const selection = this.store.getForkSelection(params.threadId);
         const target = this.epochs.resolve(params.threadId);
-        if (!selection || selection.status !== "pending" || !target) {
-            throw invalidParams(`Thread '${params.threadId}' is not awaiting a logical fork selection.`);
+        if (!target)
+            throw invalidParams(`Unknown logical thread '${params.threadId}'.`);
+        if (!Number.isInteger(params.numTurns) || params.numTurns < 0) {
+            throw invalidParams("numTurns must be a non-negative integer.");
         }
-        const turns = this.store.listLogicalTurns(params.threadId);
+        const pendingFork = selection?.status === "pending" ? selection : undefined;
+        const currentTurns = await this.currentBackendTurns(target, this.daemonStock ?? clientStock);
+        const turns = this.epochs.snapshotTurns(params.threadId, currentTurns);
         const keep = turns.length - params.numTurns;
         if (keep <= 0)
-            throw invalidParams("Fork rollback removed every provider turn.");
+            throw invalidParams("Rollback removed every provider turn.");
         const retained = turns.slice(0, keep);
         const boundary = [...retained].reverse().find((turn) => turn.epochId && turn.providerTurnId);
         if (!boundary?.epochId || !boundary.providerTurnId) {
-            throw invalidParams("Fork selection has no provider-backed turn boundary.");
+            throw invalidParams("Rollback has no provider-backed turn boundary.");
         }
         const selectedEpoch = this.store.getEpoch(boundary.epochId);
-        if (!selectedEpoch || selectedEpoch.publicThreadId !== selection.sourcePublicThreadId) {
-            throw invalidParams("Fork selection points outside the source provider lineage.");
+        const selectedLineage = pendingFork?.sourcePublicThreadId ?? params.threadId;
+        if (!selectedEpoch || !this.store.epochBelongsToLineage(selectedLineage, selectedEpoch.id)) {
+            throw invalidParams("Rollback points outside the thread's provider lineage.");
+        }
+        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, backend, true) };
+            }
+            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, rolled.thread, true) };
         }
         let forked;
         let stockBuildOwner;
@@ -649,16 +737,17 @@ export class CrossProviderForks {
             ...forked.thread,
             id: params.threadId,
             sessionId: target.logical.thread.sessionId,
-            forkedFromId: selection.sourcePublicThreadId,
-            parentThreadId: null,
+            forkedFromId: target.logical.thread.forkedFromId,
+            parentThreadId: target.logical.thread.parentThreadId,
             createdAt: target.logical.thread.createdAt,
             name: target.logical.thread.name,
             turns: [],
         };
-        const committed = this.store.commitForkSelection({
+        const committed = this.store.commitLogicalRollback({
             targetPublicThreadId: params.threadId,
-            expectedProvisionalEpochId: selection.provisionalEpochId,
-            selectedSourceEpochId: selectedEpoch.id,
+            expectedCurrentEpochId: target.epoch.id,
+            expectedThreadRevision: target.logical.revision,
+            selectedEpochId: selectedEpoch.id,
             targetEpoch: {
                 id: uuidv7(),
                 provider: selectedEpoch.provider,
@@ -678,18 +767,20 @@ export class CrossProviderForks {
         if (!committed) {
             if (stockBuildOwner)
                 this.stockTargetBuilds.delete(stockBuildOwner);
-            throw new Error("Logical fork selection lost its atomic commit boundary.");
+            throw new Error("Logical rollback lost its atomic commit boundary.");
         }
         this.subscriptions?.suppress(target.epoch.backendThreadId);
         this.subscriptions?.aliasThread(forked.thread.id, params.threadId);
         if (stockBuildOwner)
             this.stockTargetBuilds.delete(stockBuildOwner);
-        if (selectedEpoch.provider === "claude")
-            await this.claude.announceThread(forked.thread);
-        else
-            this.subscriptions?.emitPublic(params.threadId, "thread/started", {
-                thread: this.epochs.projectThread(params.threadId, forked.thread, true),
-            });
+        if (pendingFork) {
+            if (selectedEpoch.provider === "claude")
+                await this.claude.announceThread(forked.thread);
+            else
+                this.subscriptions?.emitPublic(params.threadId, "thread/started", {
+                    thread: this.epochs.projectThread(params.threadId, forked.thread, true),
+                });
+        }
         this.subscriptions?.emitPublic(params.threadId, "thread/settings/updated", {
             threadId: params.threadId,
             threadSettings: {
@@ -1335,20 +1426,20 @@ export class CrossProviderForks {
     }
     async deleteLogicalThread(publicThreadId, clientStock) {
         const stock = this.daemonStock ?? clientStock;
+        this.store.cancelProviderSwitches(publicThreadId, "Task deleted.");
         const mappings = this.store.listBackendMappings()
             .filter((mapping) => mapping.publicThreadId === publicThreadId
             && !mapping.backendThreadId.startsWith("ccodex-provisional:"));
         for (const mapping of mappings)
             this.subscriptions?.suppress(mapping.backendThreadId);
+        this.store.deleteLogicalThread(publicThreadId);
+        this.subscriptions?.threadDeleted(publicThreadId);
         await Promise.allSettled(mappings.map((mapping) => mapping.provider === "claude"
             ? this.claude.deleteThread(mapping.backendThreadId)
             : stock.request("thread/delete", { threadId: mapping.backendThreadId })));
         for (const mapping of mappings) {
             this.subscriptions?.unaliasThread(mapping.backendThreadId);
         }
-        this.store.clearPending(publicThreadId);
-        this.store.deleteLogicalThread(publicThreadId);
-        this.subscriptions?.threadDeleted(publicThreadId);
     }
     async providerSwitchSource(job, stock, _connectionId) {
         const resolved = this.epochs.resolve(job.publicThreadId);