@gkorepanov/ccodex 0.3.0 → 0.4.1

package/dist/handoff/service.d.ts

@@ -1,41 +1,111 @@
+import type { Thread } from "../codex/generated/v2/Thread.js";
 import type { ThreadForkParams } from "../codex/generated/v2/ThreadForkParams.js";
 import type { ThreadForkResponse } from "../codex/generated/v2/ThreadForkResponse.js";
 import type { ThreadItemsListParams } from "../codex/generated/v2/ThreadItemsListParams.js";
 import type { ThreadItemsListResponse } from "../codex/generated/v2/ThreadItemsListResponse.js";
+import type { ThreadRollbackParams } from "../codex/generated/v2/ThreadRollbackParams.js";
+import type { ThreadRollbackResponse } from "../codex/generated/v2/ThreadRollbackResponse.js";
 import type { ThreadReadParams } from "../codex/generated/v2/ThreadReadParams.js";
 import type { ThreadReadResponse } from "../codex/generated/v2/ThreadReadResponse.js";
 import type { ThreadResumeParams } from "../codex/generated/v2/ThreadResumeParams.js";
 import type { ThreadResumeResponse } from "../codex/generated/v2/ThreadResumeResponse.js";
 import type { ThreadSettings } from "../codex/generated/v2/ThreadSettings.js";
 import type { ThreadSettingsUpdateParams } from "../codex/generated/v2/ThreadSettingsUpdateParams.js";
+import type { ThreadStartParams } from "../codex/generated/v2/ThreadStartParams.js";
 import type { ThreadTurnsListParams } from "../codex/generated/v2/ThreadTurnsListParams.js";
 import type { ThreadTurnsListResponse } from "../codex/generated/v2/ThreadTurnsListResponse.js";
+import type { Turn } from "../codex/generated/v2/Turn.js";
 import type { TurnStartParams } from "../codex/generated/v2/TurnStartParams.js";
 import type { ClaudeService } from "../claude/service.js";
 import type { StockRpc } from "../gateway/stockRpc.js";
-import { HandoffStore, type PendingProviderSwitch, type StockHistoryOverlay } from "./store.js";
+import type { SubscriptionHub } from "../gateway/subscriptions.js";
+import { HandoffStore, type PendingProviderSwitch, type ProviderKind, type StockHistoryOverlay } from "./store.js";
+import { type ResolvedProviderEpoch } from "./providerEpochs.js";
+export declare const HANDOFF_DAEMON_CONNECTION_ID = "ccodex-handoff-daemon";
+export interface LogicalRequestResult {
+    readonly provider: ProviderKind;
+    readonly result: unknown;
+    readonly after?: () => Promise<void> | void;
+}
 export declare class CrossProviderForks {
     private readonly store;
     private readonly claude;
+    private readonly renamePrompt;
+    private readonly epochs;
     private readonly internalStockThreads;
+    private readonly suppressedInternalStockThreads;
     private readonly internalStockTurns;
+    private readonly internalStockBuilds;
     private readonly stockTargetBuilds;
-    constructor(store: HandoffStore, claude: ClaudeService);
+    private readonly systemEphemeralThreads;
+    private readonly directTitleCandidates;
+    private readonly titleTurns;
+    private readonly stockServerRequests;
+    private readonly stockServerRequestAliases;
+    private readonly recentDurableProviders;
+    private daemonStock?;
+    private subscriptions?;
+    private jobTail;
+    constructor(store: HandoffStore, claude: ClaudeService, renamePrompt?: string | null);
     pending(threadId: string): PendingProviderSwitch | undefined;
+    logical(threadId: string): ResolvedProviderEpoch | undefined;
+    hiddenBackendIds(provider?: ProviderKind): Set<string>;
+    projectThreadCatalog(stockThreads: Thread[], claudeThreads: Thread[]): Thread[];
+    projectLoadedThreadIds(stockIds: string[], claudeIds: string[]): string[];
+    projectStockMessage(message: {
+        id?: string | number;
+        method?: string;
+        params?: unknown;
+    }): boolean;
+    ownsStockBackendMessage(message: {
+        params?: unknown;
+    }): boolean;
+    resolveStockServerRequest(requestId: string, result: unknown): Promise<boolean>;
+    requestLogical(method: string, publicParams: Record<string, unknown>, clientStock: StockRpc): Promise<LogicalRequestResult>;
+    private requestProvisionalLogical;
+    forkLogical(params: ThreadForkParams, clientStock: StockRpc): Promise<ThreadForkResponse>;
+    rollbackLogicalFork(params: ThreadRollbackParams, clientStock: StockRpc, connectionId?: string): Promise<ThreadRollbackResponse>;
+    configureDaemonStock(stock: StockRpc): void;
+    configureSubscriptions(subscriptions: SubscriptionHub): void;
+    claimFailedFork(threadId: string): string | undefined;
+    drain(): Promise<void>;
+    switchProviderTurn(params: TurnStartParams, compactionTurn: Turn, clientStock: StockRpc, connectionId: string, compacted: () => void): Promise<void>;
+    private runProviderSwitchJob;
+    private recoverProviderSwitch;
     interceptSettings(params: ThreadSettingsUpdateParams): {
         handled: boolean;
         notification?: ThreadSettings;
     };
+    stageTurnSwitch(params: TurnStartParams): PendingProviderSwitch | undefined;
     blockedTurnTarget(params: TurnStartParams): string | undefined;
-    shouldFork(params: ThreadForkParams): boolean;
-    fork(params: ThreadForkParams, stock: StockRpc, connectionId?: string): Promise<ThreadForkResponse>;
+    isSystemEphemeralFork(params: ThreadForkParams): boolean;
+    forkSystemEphemeral(params: ThreadForkParams, stock: StockRpc, connectionId: string): Promise<ThreadForkResponse>;
     overlay(threadId: string): StockHistoryOverlay | undefined;
     ownsInternalStockThread(threadId: string): boolean;
+    captureInternalStockMessage(_connectionId: string, message: {
+        method: string;
+        params?: unknown;
+    }): boolean;
+    registerForwardedEphemeralCandidate(connectionId: string, threadId: string, params: ThreadStartParams | ThreadForkParams): void;
+    observeDurableThread(connectionId: string, provider: ProviderKind): void;
+    observeDurableTurn(connectionId: string, params: TurnStartParams): void;
+    prepareTitleTurn(connectionId: string, params: TurnStartParams): TurnStartParams;
+    rewriteTitleMessages(message: {
+        method: string;
+        params?: unknown;
+    }): Array<{
+        method: string;
+        params?: unknown;
+    }> | undefined;
     suppressStockTargetMessage(connectionId: string, message: {
+        id?: string | number;
         method: string;
         params?: unknown;
     }): boolean;
-    detachConnection(connectionId: string): void;
+    private flushStockTargetBuild;
+    releaseSystemEphemeral(connectionId: string, threadId: string): boolean;
+    ownsSystemEphemeral(connectionId: string, threadId: string): boolean;
+    detachConnection(connectionId: string, stock: StockRpc): Promise<void>;
     recordInternalStockMessage(message: {
         method: string;
         params?: unknown;
@@ -46,9 +116,19 @@ export declare class CrossProviderForks {
     itemsOverlay(params: ThreadItemsListParams, stock: StockRpc): Promise<ThreadItemsListResponse>;
     clearThread(threadId: string): void;
     close(): void;
+    private seedProviderSwitch;
+    private currentBackendTurns;
+    private patchLogicalThread;
+    private updateLogicalEpochFromParams;
+    private deleteLogicalThread;
+    private providerSwitchSource;
+    private providerSwitchMaterial;
+    private providerSwitchSummary;
+    private targetThreadStart;
+    private commitProviderSwitch;
     private summarizeStock;
+    private registerInternalStockThread;
     private waitStockTurn;
-    private createStockFork;
     private requireOverlay;
     private patchThread;
     private fullOverlayTurns;