recoveryOutcomeClearsQueuedSessionState,

recoveryOutcomeMutatesSessionState,

recoveryOutcomeReleasedCount,

resolveStuckSessionRecoveryRef,

type StuckSessionRecoveryOutcome,

type StuckSessionRecoveryRequest,

} from "./diagnostic-session-recovery.js";

}

function recoveryRequestKey(request: StuckSessionRecoveryRequest): string | undefined {

const ref = request.sessionKey?.trim() || request.sessionId?.trim();

if (!ref) {

return undefined;

}

// In-flight dedup must collapse concurrent recoveries for the same logical

// session, so it uses the same granularity as the runtime's recoveryKey

// (ref only). Mixing stateGeneration into the key lets a generation bump

// during the in-flight window (queued message during abort/drain await) pass

// the same session through as a distinct request, emitting a duplicate

// session.recovery.requested event while the runtime still skips it as

// already_in_flight. Staleness is validated separately via stateGeneration

// in applyRecoveryOutcomeToDiagnosticState and the runtime stale check.

return ref;

return resolveStuckSessionRecoveryRef(request);

}

function isRecoveryPromiseLike(

staleActiveProgressAbortMs?: number;

};

export function resolveStuckSessionRecoveryRef(

params: Pick<StuckSessionRecoveryRequest, "sessionId" | "sessionKey">,

): string | undefined {

// In-flight recovery gates must key by logical session only; generation is

// stale-state evidence, not concurrency identity.

return params.sessionKey?.trim() || params.sessionId?.trim() || undefined;

}

type DiagnosticSessionRecoveryBaseOutcome = {

sessionId?: string;

sessionKey?: string;

} from "./diagnostic-session-context.js";

import {

formatRecoveryOutcome,

resolveStuckSessionRecoveryRef,

type StuckSessionRecoveryOutcome,

type StuckSessionRecoveryRequest,

} from "./diagnostic-session-recovery.js";

return typeof lastProgressAgeMs === "number" && lastProgressAgeMs >= params.staleAbortMs;

}

function recoveryKey(params: StuckSessionRecoveryParams): string | undefined {

return params.sessionKey?.trim() || params.sessionId?.trim() || undefined;

}

function formatRecoveryContext(

params: StuckSessionRecoveryParams,

extra?: { activeSessionId?: string; lane?: string; activeCount?: number; queuedCount?: number },

export async function recoverStuckDiagnosticSession(

params: StuckSessionRecoveryParams,

): Promise<StuckSessionRecoveryOutcome> {

const key = recoveryKey(params);

const key = resolveStuckSessionRecoveryRef(params);

if (!key || recoveriesInFlight.has(key)) {

return {

status: "skipped",

fileActiveWorkSessionId ??

params.sessionId)

: (fileActiveWorkSessionId ?? params.sessionId);

const laneKey = params.sessionKey?.trim() || params.sessionId?.trim();

const sessionLane = laneKey ? resolveEmbeddedSessionLane(laneKey) : null;

const sessionLane = key ? resolveEmbeddedSessionLane(key) : null;

let aborted = false;

let drained = true;

let forceCleared = false;