@tea-agent/loop-agent 0.40.0-next.1 → 0.40.0-next.10

package/dist/worker/console/chat/turn-process.js

@@ -53,6 +53,9 @@ export function hydrateSessionThread(raw) {
                 role: "assistant",
                 text: item.text,
                 createdAt,
+                ...(item.kind === "provider-error" && item.providerError
+                    ? { kind: item.kind, providerError: item.providerError }
+                    : {}),
                 ...(content && content.length > 0 ? { content } : {}),
             });
             flushPendingToAssistant(item.id);
@@ -154,9 +157,23 @@ function appendAssistantUnmatchedTools(group, assistant, processItems, usedToolI
 function fillProcessDetails(group) {
     const usedToolIds = new Set();
     const processItems = [];
-    const prior = group.assistants.slice(0, -1);
-    const finalAssistant = group.assistants.at(-1);
-    for (const assistant of prior) {
+    const lastAssistant = group.assistants.at(-1);
+    const finalAssistant = lastAssistant?.kind === "provider-error" ? undefined : lastAssistant;
+    const finalIndex = finalAssistant
+        ? group.assistants.lastIndexOf(finalAssistant)
+        : -1;
+    for (const [index, assistant] of group.assistants.entries()) {
+        if (index === finalIndex)
+            continue;
+        if (assistant.kind === "provider-error" && assistant.providerError) {
+            emitProcessBlocks(getDisplayableAssistantBlocks(assistant.content ?? []), group, processItems, usedToolIds);
+            appendAssistantUnmatchedTools(group, assistant, processItems, usedToolIds);
+            processItems.push({
+                kind: "provider-error",
+                error: assistant.providerError,
+            });
+            continue;
+        }
         emitProcessBlocks(getDisplayableAssistantBlocks(assistant.content ?? []), group, processItems, usedToolIds);
         appendAssistantUnmatchedTools(group, assistant, processItems, usedToolIds);
     }
@@ -292,55 +309,3 @@ export function selectRecentTurnGroups(groups, limit) {
         return [...groups];
     return groups.slice(-limit);
 }
-export function processGroupSummary(tools, options) {
-    const count = tools.length;
-    const thinkingCount = options?.thinkingCount ?? 0;
-    const textCount = options?.textCount ?? 0;
-    const activityCount = options?.activityCount ?? 0;
-    const stepCount = thinkingCount + textCount + activityCount + count;
-    const errorCount = tools.filter((t) => t.status === "error").length +
-        (options?.activityErrorCount ?? 0);
-    const runningCount = tools.filter((t) => t.status === "running").length +
-        (options?.activityRunningCount ?? 0);
-    const parts = [`处理详情 · ${stepCount} 步`];
-    if (count > 0)
-        parts.push(`${count} 工具`);
-    if (activityCount > 0)
-        parts.push(`${activityCount} 进展`);
-    if (errorCount > 0)
-        parts.push(`${errorCount} 出错`);
-    else if (runningCount > 0)
-        parts.push("运行中");
-    return { count, errorCount, runningCount, stepCount, label: parts.join(" · ") };
-}
-/** Summary over rendered process items. */
-export function summarizeProcessItems(items) {
-    const tools = [];
-    let thinkingCount = 0;
-    let textCount = 0;
-    let activityCount = 0;
-    let activityErrorCount = 0;
-    let activityRunningCount = 0;
-    for (const item of items) {
-        if (item.kind === "thinking")
-            thinkingCount += 1;
-        else if (item.kind === "text")
-            textCount += 1;
-        else if (item.kind === "activity") {
-            activityCount += 1;
-            if (item.activity.kind === "error")
-                activityErrorCount += 1;
-            else if (item.activity.kind === "progress")
-                activityRunningCount += 1;
-        }
-        else
-            tools.push(item.tool);
-    }
-    return processGroupSummary(tools, {
-        thinkingCount,
-        textCount,
-        activityCount,
-        activityErrorCount,
-        activityRunningCount,
-    });
-}

package/dist/worker/console/chat/user-questions.js

@@ -0,0 +1,266 @@
+import { randomBytes } from "node:crypto";
+import path from "node:path";
+import { readJsonIfExists, writeSecureJson } from "../app-data.js";
+function questionFile(root, sessionId) {
+    const safe = sessionId.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 180);
+    return path.join(root, `${safe}.json`);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeQuestions(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 20) {
+        throw new Error("ask_user_question requires 1-20 questions");
+    }
+    const ids = new Set();
+    return value.map((raw, index) => {
+        if (!isRecord(raw))
+            throw new Error(`question ${index + 1} must be an object`);
+        const id = typeof raw.id === "string" ? raw.id.trim() : "";
+        const question = typeof raw.question === "string" ? raw.question.trim() : "";
+        if (!id || !question)
+            throw new Error(`question ${index + 1} requires id and question`);
+        if (ids.has(id))
+            throw new Error(`duplicate question id: ${id}`);
+        ids.add(id);
+        const options = raw.options === undefined ? undefined : normalizeOptions(raw.options, id);
+        return {
+            id,
+            question,
+            ...(typeof raw.header === "string" && raw.header.trim()
+                ? { header: raw.header.trim().slice(0, 80) }
+                : {}),
+            ...(typeof raw.detail === "string" && raw.detail.trim()
+                ? { detail: raw.detail.trim().slice(0, 4000) }
+                : {}),
+            ...(options ? { options } : {}),
+            ...(raw.multi_select === true ? { multiSelect: true } : {}),
+        };
+    });
+}
+function normalizeOptions(value, questionId) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 12) {
+        throw new Error(`question ${questionId} options must contain 1-12 items`);
+    }
+    const labels = new Set();
+    return value.map((raw, index) => {
+        if (!isRecord(raw) || typeof raw.label !== "string" || !raw.label.trim()) {
+            throw new Error(`question ${questionId} option ${index + 1} requires a label`);
+        }
+        const label = raw.label.trim();
+        if (labels.has(label))
+            throw new Error(`duplicate option label: ${label}`);
+        labels.add(label);
+        return {
+            label,
+            ...(typeof raw.description === "string" && raw.description.trim()
+                ? { description: raw.description.trim().slice(0, 300) }
+                : {}),
+        };
+    });
+}
+function normalizeAnswer(value, questions) {
+    if (!isRecord(value) || !Array.isArray(value.answers))
+        throw new Error("answers must be an array");
+    const byId = new Map(questions.map((question) => [question.id, question]));
+    const seen = new Set();
+    const answers = value.answers.map((raw) => {
+        if (!isRecord(raw) || typeof raw.id !== "string")
+            throw new Error("answer id is required");
+        const id = raw.id.trim();
+        const question = byId.get(id);
+        if (!question || seen.has(id))
+            throw new Error(`answer does not match question: ${id}`);
+        seen.add(id);
+        const selected = Array.isArray(raw.selected)
+            ? raw.selected.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean)
+            : [];
+        const allowed = new Set((question.options ?? []).map((option) => option.label));
+        if (selected.some((item) => !allowed.has(item)))
+            throw new Error(`answer contains an unknown option for ${id}`);
+        if (!question.multiSelect && selected.length > 1)
+            throw new Error(`question ${id} accepts one option`);
+        const custom = typeof raw.custom === "string" ? raw.custom.trim().slice(0, 4000) : "";
+        return { id, selected, ...(custom ? { custom } : {}) };
+    });
+    if (seen.size !== questions.length)
+        throw new Error("every question requires an answer or skip entry");
+    return { answers };
+}
+export class UserQuestionRegistry {
+    root;
+    pending = new Map();
+    /** Serialize first-write and resolve/cancel writes for one session. */
+    persistence = new Map();
+    waiters = new Map();
+    turnIds = new Map();
+    listeners = new Set();
+    constructor(root) {
+        this.root = root;
+    }
+    setTurn(sessionId, turnId) {
+        this.turnIds.set(sessionId, turnId);
+    }
+    clearTurn(sessionId) {
+        this.turnIds.delete(sessionId);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async get(sessionId) {
+        const memory = this.pending.get(sessionId);
+        if (memory?.status === "pending")
+            return structuredClone(memory);
+        const disk = await readJsonIfExists(questionFile(this.root, sessionId));
+        if (disk?.status === "pending") {
+            this.pending.set(sessionId, disk);
+            return structuredClone(disk);
+        }
+        return undefined;
+    }
+    async ask(input) {
+        const questions = normalizeQuestions(input.questions);
+        if (input.signal?.aborted)
+            throw new Error("USER_QUESTION_ABORTED");
+        if (await this.get(input.sessionId))
+            throw new Error("USER_QUESTION_ALREADY_PENDING");
+        // Two tool calls can finish the disk lookup in the same turn. Re-check the
+        // in-memory lease after that await so only the first one can publish.
+        if (this.pending.get(input.sessionId)?.status === "pending") {
+            throw new Error("USER_QUESTION_ALREADY_PENDING");
+        }
+        const now = new Date().toISOString();
+        const question = {
+            schemaVersion: 1,
+            requestId: `question_${randomBytes(12).toString("hex")}`,
+            sessionId: input.sessionId,
+            toolCallId: input.toolCallId,
+            ...(this.turnIds.get(input.sessionId) ? { turnId: this.turnIds.get(input.sessionId) } : {}),
+            questions,
+            createdAt: now,
+            updatedAt: now,
+            status: "pending",
+            version: 1,
+        };
+        this.pending.set(input.sessionId, question);
+        // Register the waiter before the first persistence await. A turn abort can
+        // arrive while the request is being written; registering afterwards leaves
+        // cancel() with nobody to reject and the tool promise would hang forever.
+        let persisted = false;
+        let abortRequested = false;
+        const waiting = new Promise((resolve, reject) => {
+            const onAbort = () => {
+                abortRequested = true;
+                if (persisted) {
+                    void this.cancel(input.sessionId, question.requestId, "TURN_ABORTED").catch(reject);
+                }
+            };
+            this.waiters.set(input.sessionId, {
+                resolve: (answer) => {
+                    input.signal?.removeEventListener("abort", onAbort);
+                    resolve(answer);
+                },
+                reject: (error) => {
+                    input.signal?.removeEventListener("abort", onAbort);
+                    reject(error);
+                },
+            });
+            if (input.signal?.aborted)
+                onAbort();
+            else
+                input.signal?.addEventListener("abort", onAbort, { once: true });
+        });
+        try {
+            await this.persist(input.sessionId, question);
+            persisted = true;
+            if (abortRequested) {
+                await this.cancel(input.sessionId, question.requestId, "TURN_ABORTED");
+                return waiting;
+            }
+            this.emit({ type: "requested", question });
+        }
+        catch (error) {
+            const waiter = this.waiters.get(input.sessionId);
+            this.pending.delete(input.sessionId);
+            this.waiters.delete(input.sessionId);
+            const failure = error instanceof Error ? error : new Error(String(error));
+            if (waiter) {
+                waiter.reject(failure);
+                return waiting;
+            }
+            throw failure;
+        }
+        return waiting;
+    }
+    async answer(sessionId, requestId, rawAnswer) {
+        await this.persistence.get(sessionId);
+        const current = await this.get(sessionId);
+        if (!current)
+            throw new Error("USER_QUESTION_NOT_FOUND");
+        if (current.requestId !== requestId)
+            throw new Error("USER_QUESTION_STALE");
+        const answer = normalizeAnswer(rawAnswer, current.questions);
+        const resolved = {
+            ...current,
+            status: "resolved",
+            answer,
+            updatedAt: new Date().toISOString(),
+            version: current.version + 1,
+        };
+        this.pending.delete(sessionId);
+        await this.persist(sessionId, resolved);
+        this.emit({ type: "resolved", question: resolved });
+        const waiter = this.waiters.get(sessionId);
+        this.waiters.delete(sessionId);
+        waiter?.resolve(answer);
+        return resolved;
+    }
+    async cancel(sessionId, requestId, reason = "USER_CANCELLED") {
+        await this.persistence.get(sessionId);
+        const current = await this.get(sessionId);
+        if (!current)
+            throw new Error("USER_QUESTION_NOT_FOUND");
+        if (current.requestId !== requestId)
+            throw new Error("USER_QUESTION_STALE");
+        const cancelled = {
+            ...current,
+            status: "cancelled",
+            cancelReason: reason,
+            updatedAt: new Date().toISOString(),
+            version: current.version + 1,
+        };
+        this.pending.delete(sessionId);
+        await this.persist(sessionId, cancelled);
+        this.emit({ type: "cancelled", question: cancelled });
+        const waiter = this.waiters.get(sessionId);
+        this.waiters.delete(sessionId);
+        waiter?.reject(new Error(reason));
+        return cancelled;
+    }
+    async cancelForSession(sessionId, reason = "SESSION_DISPOSED") {
+        const current = await this.get(sessionId);
+        if (current)
+            await this.cancel(sessionId, current.requestId, reason);
+    }
+    emit(change) {
+        for (const listener of this.listeners) {
+            try {
+                listener(change);
+            }
+            catch { /* observers never break the waiter */ }
+        }
+    }
+    async persist(sessionId, question) {
+        const write = writeSecureJson(questionFile(this.root, sessionId), question);
+        this.persistence.set(sessionId, write);
+        try {
+            await write;
+        }
+        finally {
+            if (this.persistence.get(sessionId) === write) {
+                this.persistence.delete(sessionId);
+            }
+        }
+    }
+}

package/dist/worker/console/chat/workspace-landing.js

@@ -1,5 +1,70 @@
 export const ACTIVE_CHAT_SESSION_STORAGE_KEY = "loop-console.operator-chat.active-session.v1";
+export const ACTIVE_CHAT_SESSION_BY_WORKSPACE_STORAGE_KEY = "loop-console.operator-chat.active-session-by-workspace.v1";
 export const DEFAULT_LANDING_STORAGE_KEY = "loop-console.operator-chat.default-landing.v1";
+function readWorkspaceSessionMap(storage) {
+    try {
+        const parsed = JSON.parse(storage.getItem(ACTIVE_CHAT_SESSION_BY_WORKSPACE_STORAGE_KEY) ?? "{}");
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        return Object.fromEntries(Object.entries(parsed).filter((entry) => Boolean(entry[0].trim()) &&
+            typeof entry[1] === "string" &&
+            Boolean(entry[1].trim())));
+    }
+    catch {
+        return {};
+    }
+}
+/** Resolve the selected Chat session from client state. The workspace map is
+ * authoritative; the former global key is only a safe, server-validated
+ * migration fallback for users upgrading from the single-selection layout. */
+export function readActiveChatSessionId(storage, workspaceId) {
+    const scope = workspaceId?.trim();
+    if (scope) {
+        const map = readWorkspaceSessionMap(storage);
+        const scoped = map[scope]?.trim();
+        if (scoped)
+            return scoped;
+        // Once the map exists, an absent workspace means "no selected session";
+        // never fall back to another workspace's global legacy selection.
+        if (Object.keys(map).length > 0)
+            return null;
+    }
+    return storage.getItem(ACTIVE_CHAT_SESSION_STORAGE_KEY)?.trim() || null;
+}
+/** Remember the active session for its owning workspace while retaining the
+ * global key for existing non-Chat consumers that refer to the visible session. */
+export function rememberActiveChatSession(storage, workspaceId, sessionId) {
+    const id = sessionId.trim();
+    if (!id)
+        return;
+    storage.setItem(ACTIVE_CHAT_SESSION_STORAGE_KEY, id);
+    const scope = workspaceId?.trim();
+    if (!scope)
+        return;
+    const map = readWorkspaceSessionMap(storage);
+    map[scope] = id;
+    storage.setItem(ACTIVE_CHAT_SESSION_BY_WORKSPACE_STORAGE_KEY, JSON.stringify(map));
+}
+/** Forget one workspace's invalid/deleted selection without disturbing the
+ * last session remembered for any other workspace. */
+export function forgetActiveChatSession(storage, workspaceId, sessionId) {
+    const scope = workspaceId?.trim();
+    if (scope) {
+        const map = readWorkspaceSessionMap(storage);
+        if (!sessionId || map[scope] === sessionId)
+            delete map[scope];
+        if (Object.keys(map).length > 0) {
+            storage.setItem(ACTIVE_CHAT_SESSION_BY_WORKSPACE_STORAGE_KEY, JSON.stringify(map));
+        }
+        else {
+            storage.removeItem(ACTIVE_CHAT_SESSION_BY_WORKSPACE_STORAGE_KEY);
+        }
+    }
+    const global = storage.getItem(ACTIVE_CHAT_SESSION_STORAGE_KEY)?.trim();
+    if (!sessionId || global === sessionId) {
+        storage.removeItem(ACTIVE_CHAT_SESSION_STORAGE_KEY);
+    }
+}
 function configuredLanding(value) {
     const normalized = value?.trim().toLowerCase();
     if (normalized === "chat")
@@ -28,6 +93,20 @@ function readWorkspaceParams(query) {
         ...(read("fromNodeId") ? { fromNodeId: read("fromNodeId") } : {}),
         ...(read("featureId") ? { featureId: read("featureId") } : {}),
         ...(read("intent") ? { intent: read("intent") } : {}),
+        ...(read("workspaceId") ? { workspaceId: read("workspaceId") } : {}),
+        ...(read("sessionId") ? { sessionId: read("sessionId") } : {}),
+    };
+}
+export function resolveLegacyWorkspaceSelection(location, knownWorkspaceIds) {
+    const parsed = parseConsoleRoute(location);
+    const requested = parsed?.workspaceId?.trim();
+    if (parsed && requested && !knownWorkspaceIds.includes(requested)) {
+        return { status: "unknown-workspace", workspaceId: requested };
+    }
+    return {
+        status: "ok",
+        workspace: parsed?.workspace ?? resolveDefaultLanding({ location }),
+        params: parsed ?? {},
     };
 }
 /** Parse `#/tasks?taskId=…` hash routes (Observe-style virtual paths). */

package/dist/worker/console/console-handoff.js

@@ -0,0 +1,82 @@
+import { createHash, randomBytes } from "node:crypto";
+const HANDOFF_ENV = "LOOP_CONSOLE_HANDOFF_V1";
+const HANDOFF_HASH_ENV = "LOOP_CONSOLE_HANDOFF_SHA256";
+function canonicalJson(value) {
+    return JSON.stringify(value);
+}
+function digest(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+export function createConsoleHandoff(input) {
+    const handoff = {
+        schemaVersion: 1,
+        consoleInstanceId: `console_${randomBytes(16).toString("hex")}`,
+        ...input,
+    };
+    const encoded = canonicalJson(handoff);
+    return {
+        handoff,
+        env: {
+            [HANDOFF_ENV]: Buffer.from(encoded, "utf8").toString("base64url"),
+            [HANDOFF_HASH_ENV]: digest(encoded),
+        },
+    };
+}
+/** Parse an exact, hash-bound handoff contract inherited by the replacement process. */
+export function readConsoleHandoff(env) {
+    const encoded = env[HANDOFF_ENV];
+    const expectedDigest = env[HANDOFF_HASH_ENV];
+    if (!encoded && !expectedDigest)
+        return undefined;
+    if (!encoded || !expectedDigest)
+        throw new Error("console handoff contract is incomplete");
+    let raw;
+    try {
+        raw = Buffer.from(encoded, "base64url").toString("utf8");
+    }
+    catch {
+        throw new Error("console handoff payload is invalid");
+    }
+    if (digest(raw) !== expectedDigest)
+        throw new Error("console handoff hash mismatch");
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("console handoff payload is not JSON");
+    }
+    const value = parsed;
+    if (value.schemaVersion !== 1 ||
+        !Number.isInteger(value.oldPid) ||
+        value.oldPid <= 0 ||
+        typeof value.repoRoot !== "string" ||
+        typeof value.host !== "string" ||
+        !Number.isInteger(value.port) ||
+        value.port < 0 ||
+        typeof value.targetVersion !== "string" ||
+        typeof value.consoleInstanceId !== "string") {
+        throw new Error("console handoff payload has invalid fields");
+    }
+    return value;
+}
+export async function waitForOldConsoleExit(oldPid, options = {}) {
+    const isAlive = options.isAlive ?? ((pid) => {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const timeoutMs = options.timeoutMs ?? 15_000;
+    const started = Date.now();
+    while (isAlive(oldPid)) {
+        if (Date.now() - started >= timeoutMs) {
+            throw new Error(`old Console PID ${oldPid} did not exit before handoff timeout`);
+        }
+        await sleep(50);
+    }
+}

package/dist/worker/console/console-update-and-init.js

@@ -0,0 +1,115 @@
+import semver from "semver";
+function notRunMaintenance(channel) {
+    return {
+        package: { status: "failed", channel },
+        initialization: { status: "not-run", pendingPaths: [] },
+        handoff: { status: "not-needed" },
+    };
+}
+function failed(code, message, maintenance = notRunMaintenance("latest")) {
+    return {
+        state: "failed",
+        maintenance,
+        errorCode: code,
+        errorMessage: message,
+    };
+}
+/**
+ * Deterministic core for the Console-only maintenance operation. It contains
+ * no HTTP, model, or process-global calls, which makes the safety ordering
+ * independently testable and keeps the caller responsible for privileged
+ * handoff mechanics.
+ */
+export async function performConsoleUpdateAndInit(deps, channel = "latest") {
+    const preflight = await deps.preflight();
+    if (!preflight.ok) {
+        return failed(preflight.code, preflight.message, notRunMaintenance(channel));
+    }
+    const target = await deps.resolveVersion(channel);
+    if (!target.ok) {
+        return failed("REGISTRY_UNAVAILABLE", `could not verify npm ${channel} (${target.reason})`, notRunMaintenance(channel));
+    }
+    if (!semver.valid(deps.currentVersion) || !semver.valid(target.version)) {
+        return failed("INVALID_VERSION", "installed or selected channel version is invalid", notRunMaintenance(channel));
+    }
+    if (channel === "latest" && semver.lt(target.version, deps.currentVersion)) {
+        return failed("REGISTRY_VERSION_REGRESSION", `npm latest ${target.version} is older than installed ${deps.currentVersion}`, notRunMaintenance(channel));
+    }
+    const release = await deps.acquireLock();
+    if (!release) {
+        return failed("UPDATE_LOCKED", "another loop-agent update is already in progress for this user", notRunMaintenance(channel));
+    }
+    try {
+        const packageChanged = target.version !== deps.currentVersion;
+        const maintenance = {
+            package: {
+                status: packageChanged ? "updated" : "current",
+                channel,
+                targetVersion: target.version,
+            },
+            initialization: { status: "not-run", pendingPaths: [] },
+            handoff: { status: "not-needed" },
+        };
+        if (packageChanged) {
+            const proof = await deps.canAutoInstall();
+            if (!proof.ok) {
+                maintenance.package = { status: "failed", channel, reason: proof.reason };
+                return failed("GLOBAL_INSTALL_UNPROVEN", proof.reason, maintenance);
+            }
+            const installed = await deps.installExact(target.version, channel);
+            if (!installed.ok) {
+                maintenance.package = { status: "failed", channel, reason: installed.reason };
+                return failed("INSTALL_FAILED", installed.reason, maintenance);
+            }
+            const verified = await deps.verifyInstalled(target.version);
+            if (!verified.ok) {
+                maintenance.package = { status: "failed", channel, reason: verified.reason };
+                return failed("INSTALL_VERIFICATION_FAILED", verified.reason, maintenance);
+            }
+        }
+        const initResult = await deps.applySafeInit();
+        maintenance.initialization = initResult.ok
+            ? { status: "clean", pendingPaths: initResult.pendingPaths }
+            : {
+                status: "needs-reconcile",
+                pendingPaths: initResult.pendingPaths,
+                message: initResult.message,
+            };
+        if (!packageChanged) {
+            return {
+                state: initResult.ok ? "succeeded" : "needs-reconcile",
+                maintenance,
+                ...(initResult.ok
+                    ? {}
+                    : {
+                        errorCode: "INIT_NEEDS_RECONCILE",
+                        errorMessage: initResult.message,
+                    }),
+            };
+        }
+        const handoff = await deps.requestHandoff({
+            targetVersion: target.version,
+            initResult,
+        });
+        if (!handoff.ok) {
+            maintenance.handoff = {
+                status: "needs-reconcile",
+                message: handoff.message,
+            };
+            return {
+                state: "needs-reconcile",
+                maintenance,
+                errorCode: "HANDOFF_FAILED",
+                errorMessage: handoff.message,
+            };
+        }
+        maintenance.handoff = {
+            status: "requested",
+            consoleInstanceId: handoff.consoleInstanceId,
+        };
+        return { state: "restarting", maintenance };
+    }
+    finally {
+        await release().catch(() => undefined);
+    }
+}