@tomflow/proflow-platform-host 0.1.30 → 0.1.31

package/dist/src/monitor-rotation-coordinator.js

@@ -0,0 +1,782 @@
+import { createHash } from "node:crypto";
+function object(value, name) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new Error(`${name}_INVALID`);
+    return value;
+}
+function string(value, name) {
+    if (typeof value !== "string" || value.length === 0)
+        throw new Error(`${name}_INVALID`);
+    return value;
+}
+function positiveInteger(value, name) {
+    if (!Number.isInteger(value) || Number(value) <= 0)
+        throw new Error(`${name}_INVALID`);
+    return Number(value);
+}
+function optionalString(value, name) {
+    return value === undefined ? undefined : string(value, name);
+}
+function parseConfig(value) {
+    const raw = object(value, "MONITOR_CONFIG");
+    if (raw.contract !== "proflow.monitor-config.v1")
+        throw new Error("MONITOR_CONFIG_INVALID");
+    const projectRef = raw.projectRef === null ? null : string(raw.projectRef, "MONITOR_PROJECT_REF");
+    const projectLocator = raw.projectLocator === null
+        ? null
+        : string(raw.projectLocator, "MONITOR_PROJECT_LOCATOR");
+    return {
+        revision: positiveInteger(raw.revision, "MONITOR_CONFIG_REVISION"),
+        enabled: raw.enabled === true,
+        notificationsEnabled: raw.notificationsEnabled === true,
+        projectRef,
+        projectLocator,
+    };
+}
+function parseShift(value, expectedShiftId) {
+    const raw = object(value, "MONITOR_SHIFT");
+    const shiftId = string(raw.shiftId, "MONITOR_SHIFT_ID");
+    if (shiftId !== expectedShiftId)
+        throw new Error("MONITOR_SHIFT_ID_MISMATCH");
+    const state = raw.state;
+    if (!new Set(["BOOTING", "ACTIVE", "DRAINING", "RETIRED", "STOPPED"]).has(String(state)))
+        throw new Error("MONITOR_SHIFT_STATE_INVALID");
+    const rotationDueAt = string(raw.rotationDueAt, "MONITOR_ROTATION_DUE_AT");
+    const deadlineAt = string(raw.deadlineAt, "MONITOR_DEADLINE_AT");
+    if (Number.isNaN(Date.parse(rotationDueAt)) ||
+        Number.isNaN(Date.parse(deadlineAt)))
+        throw new Error("MONITOR_SHIFT_TIME_INVALID");
+    return {
+        shiftId,
+        chatRef: string(raw.chatRef, "MONITOR_CHAT_REF"),
+        generation: positiveInteger(raw.generation, "MONITOR_SHIFT_GENERATION"),
+        state: state,
+        rotationDueAt,
+        deadlineAt,
+        ...(raw.bootProof === undefined ? {} : { bootProof: raw.bootProof }),
+        ...(optionalString(raw.handoffRef, "MONITOR_HANDOFF_REF") === undefined
+            ? {}
+            : { handoffRef: String(raw.handoffRef) }),
+        ...(optionalString(raw.nextChatPromptRef, "MONITOR_NEXT_CHAT_PROMPT_REF") === undefined
+            ? {}
+            : { nextChatPromptRef: String(raw.nextChatPromptRef) }),
+    };
+}
+function parseRun(value) {
+    const raw = object(value, "MONITOR_RUN");
+    if (raw.contract !== "proflow.monitor-run.v1")
+        throw new Error("MONITOR_RUN_INVALID");
+    const runId = string(raw.runId, "MONITOR_RUN_ID");
+    const shiftsRaw = object(raw.shifts, "MONITOR_SHIFTS");
+    const shifts = {};
+    for (const [shiftId, shift] of Object.entries(shiftsRaw))
+        shifts[shiftId] = parseShift(shift, shiftId);
+    const activeShiftId = raw.activeShiftId === null
+        ? null
+        : string(raw.activeShiftId, "MONITOR_ACTIVE_SHIFT_ID");
+    if (activeShiftId !== null && !shifts[activeShiftId])
+        throw new Error("MONITOR_ACTIVE_SHIFT_MISSING");
+    return {
+        runId,
+        version: positiveInteger(raw.version, "MONITOR_RUN_VERSION"),
+        activeShiftId,
+        shifts,
+    };
+}
+function parseRuns(value) {
+    if (!Array.isArray(value))
+        throw new Error("MONITOR_RUN_LIST_INVALID");
+    return value.map(parseRun);
+}
+function parseObservationIdentity(value) {
+    const raw = object(value, "MONITOR_OBSERVATION");
+    return {
+        chatRef: string(raw.chatRef, "MONITOR_CHAT_REF"),
+        url: string(raw.url, "MONITOR_CHAT_URL"),
+    };
+}
+function parseObservation(value) {
+    const raw = object(value, "MONITOR_OBSERVATION");
+    const identity = parseObservationIdentity(raw);
+    const state = raw.state;
+    if (!new Set([
+        "IDLE",
+        "GENERATING",
+        "TOOL_RUNNING",
+        "AWAITING_USER",
+        "UNKNOWN",
+    ]).has(String(state)))
+        throw new Error("MONITOR_CHAT_STATE_INVALID");
+    const settledRef = optionalString(raw.settledRef, "MONITOR_SETTLED_REF");
+    if (settledRef !== undefined && state !== "IDLE")
+        throw new Error("MONITOR_SETTLED_REF_INVALID");
+    return {
+        ...identity,
+        state: state,
+        ...(settledRef === undefined ? {} : { settledRef }),
+    };
+}
+function parseArtifact(value) {
+    const raw = object(value, "MONITOR_ARTIFACT");
+    return {
+        artifactRef: string(raw.artifactRef, "MONITOR_ARTIFACT_REF"),
+        content: string(raw.content, "MONITOR_ARTIFACT_CONTENT"),
+    };
+}
+function stableRef(kind, parts) {
+    return `monitor-${kind}:${createHash("sha256")
+        .update(JSON.stringify(parts))
+        .digest("hex")}`;
+}
+export function monitorHandoffMessageRef(input) {
+    return stableRef("handoff-request", [
+        input.runId,
+        input.shiftId,
+        input.generation,
+    ]);
+}
+export function monitorBootstrapMessageRef(input) {
+    return stableRef("bootstrap", [
+        input.runId,
+        input.shiftId,
+        input.generation,
+    ]);
+}
+export function monitorBootstrapText(input) {
+    return [
+        `你是现有 ProFlow Monitor shift：${input.shiftId}。现在只完成正式 bootstrap recovery，不创建新 Chat 或新 shift，也不要继续旧断点。`,
+        "使用 Local Dev 按当前 chat-local-engineering-protocol 与 proflow-chat-loop 恢复 authority：读取公共上下文 README、长期规则 01/02/05、CURRENT、CURRENT.REQUIRED_CONTEXT、Phase 4 的 03/04 与 latest handoff，并重新读取当前 owner/runtime facts。",
+        `完成真实读取后，使用 Workspace 的 automation/proflow-browser-extension/monitor-boot-proof.mjs 为 run ${input.runId} / shift ${input.shiftId} 发布 boot proof（必须由你这个真实 Monitor Chat 自己执行 --authorities-read）。`,
+        "boot proof 成功后停止本轮并等待系统激活；不要替维护 Chat、Product、Dev 或 Test 执行业务工作。",
+    ].join("\n");
+}
+export function monitorTurnWakeMessageRef(input) {
+    return stableRef("turn-wake", [
+        input.runId,
+        input.shiftId,
+        input.generation,
+        input.settledRef,
+    ]);
+}
+export function monitorTurnWakeText() {
+    return "请依据当前上下文、当前真实状态与既有规则，自主判断并执行当前应采取的动作。";
+}
+export function monitorNextShiftId(input) {
+    return stableRef("shift", [
+        input.runId,
+        input.shiftId,
+        input.generation + 1,
+    ]);
+}
+export function monitorNextChatMessageRef(input) {
+    return stableRef("next-chat", [
+        input.runId,
+        input.shiftId,
+        input.generation,
+        input.nextShiftId,
+    ]);
+}
+export function monitorHandoffRequestText(_input) {
+    return "请依据当前上下文、当前真实状态与既有规则，自主完成当前班次交接。";
+}
+function monitorCapability(request) {
+    return (request.capability === "monitor.chat.submit" ||
+        request.capability === "monitor.chat.create");
+}
+export async function authorizeMonitorExecution(input) {
+    try {
+        const request = input.request;
+        if (!monitorCapability(request))
+            return false;
+        if (request.callerRef !== "platform-host:monitor-rotation")
+            return false;
+        if (request.taskId !== undefined ||
+            request.nodeId !== undefined ||
+            request.runNo !== undefined ||
+            request.roleRef !== undefined ||
+            request.workerRef !== undefined ||
+            request.projectRoot !== undefined)
+            return false;
+        if (request.input.contentFingerprint !== request.input.messageRef)
+            return false;
+        const config = parseConfig(await input.monitor.invoke("config.read", {}));
+        if (!config.enabled ||
+            config.projectRef === null ||
+            config.projectLocator === null ||
+            config.revision !== request.input.configRevision ||
+            config.projectRef !== request.input.projectRef)
+            return false;
+        const run = parseRun(await input.monitor.invoke("run.read", {
+            runId: request.input.runId,
+        }));
+        if (run.version !== request.input.expectedRunVersion)
+            return false;
+        const shift = run.shifts[request.input.shiftId];
+        if (!shift || shift.generation !== request.input.generation)
+            return false;
+        const nowMs = (input.now ?? (() => new Date()))().getTime();
+        if (request.capability === "monitor.chat.create") {
+            if (shift.state !== "DRAINING" ||
+                !shift.handoffRef ||
+                !shift.nextChatPromptRef ||
+                request.input.projectLocator !== config.projectLocator)
+                return false;
+            const nextShiftId = monitorNextShiftId({
+                runId: run.runId,
+                shiftId: shift.shiftId,
+                generation: shift.generation,
+            });
+            if (request.input.nextShiftId !== nextShiftId ||
+                run.shifts[nextShiftId])
+                return false;
+            const expectedRef = monitorNextChatMessageRef({
+                runId: run.runId,
+                shiftId: shift.shiftId,
+                generation: shift.generation,
+                nextShiftId,
+            });
+            if (request.input.messageRef !== expectedRef)
+                return false;
+            const prompt = parseArtifact(await input.monitor.invoke("artifact.read", {
+                artifactRef: shift.nextChatPromptRef,
+            }));
+            return (prompt.artifactRef === shift.nextChatPromptRef &&
+                request.input.text === prompt.content);
+        }
+        if (shift.chatRef !== request.input.chatRef)
+            return false;
+        const rawObservation = await input.monitor.invoke("observation.read", {
+            chatRef: shift.chatRef,
+        });
+        const identity = parseObservationIdentity(rawObservation);
+        if (identity.chatRef !== shift.chatRef ||
+            identity.url !== request.input.conversationLocator)
+            return false;
+        if (shift.state === "BOOTING") {
+            const observation = parseObservation(rawObservation);
+            if (run.activeShiftId !== null ||
+                observation.state !== "IDLE")
+                return false;
+            const expectedRef = monitorBootstrapMessageRef({
+                runId: run.runId,
+                shiftId: shift.shiftId,
+                generation: shift.generation,
+            });
+            return (request.input.messageRef === expectedRef &&
+                request.input.text ===
+                    monitorBootstrapText({
+                        runId: run.runId,
+                        shiftId: shift.shiftId,
+                    }));
+        }
+        if (shift.state === "ACTIVE") {
+            const observation = parseObservation(rawObservation);
+            if (run.activeShiftId !== shift.shiftId ||
+                nowMs >= Date.parse(shift.rotationDueAt) ||
+                observation.state !== "IDLE" ||
+                !observation.settledRef)
+                return false;
+            const expectedRef = monitorTurnWakeMessageRef({
+                runId: run.runId,
+                shiftId: shift.shiftId,
+                generation: shift.generation,
+                settledRef: observation.settledRef,
+            });
+            if (request.input.messageRef !== expectedRef ||
+                request.input.text !== monitorTurnWakeText())
+                return false;
+            return true;
+        }
+        if (shift.state === "DRAINING") {
+            if (nowMs > Date.parse(shift.deadlineAt))
+                return false;
+            const expectedRef = monitorHandoffMessageRef({
+                runId: run.runId,
+                shiftId: shift.shiftId,
+                generation: shift.generation,
+            });
+            return (request.input.messageRef === expectedRef &&
+                request.input.text ===
+                    monitorHandoffRequestText({
+                        runId: run.runId,
+                        shiftId: shift.shiftId,
+                        generation: shift.generation,
+                        projectRef: config.projectRef,
+                    }));
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+function appliedExecutionResult(value, capability) {
+    const record = object(value, "MONITOR_EXECUTION_RECORD");
+    if (record.status !== "SUCCEEDED" ||
+        record.sideEffectState !== "APPLIED")
+        return null;
+    const result = object(record.result, "MONITOR_EXECUTION_RESULT");
+    if (result.capability !== capability)
+        return null;
+    return object(result.data, "MONITOR_EXECUTION_RESULT_DATA");
+}
+function drainingShift(run) {
+    return Object.values(run.shifts)
+        .filter((shift) => shift.state === "DRAINING")
+        .sort((left, right) => right.generation - left.generation)[0];
+}
+function initialBootingShift(run) {
+    const booting = Object.values(run.shifts).filter((shift) => shift.state === "BOOTING" && shift.generation === 1);
+    return booting.length === 1 ? booting[0] : undefined;
+}
+export function createMonitorRotationCoordinator(options) {
+    const intervalMs = options.intervalMs ?? 15_000;
+    if (!Number.isInteger(intervalMs) || intervalMs < 1_000)
+        throw new TypeError("monitor rotation interval must be an integer >= 1000");
+    const now = options.now ?? (() => new Date());
+    const drivenSettledRefs = new Map();
+    let timer;
+    let inFlight = null;
+    let stopping = false;
+    const assertRunning = () => {
+        if (stopping)
+            throw new Error("MONITOR_ROTATION_STOPPED");
+    };
+    const notifyDrive = async (config, run, shift, input) => {
+        if (!config.notificationsEnabled)
+            return { status: "DISABLED" };
+        await options.monitor.invoke("notification.enqueue", {
+            event: {
+                contract: "proflow.monitor-notification.v1",
+                eventId: stableRef("notification", [
+                    input.event,
+                    input.messageRef,
+                ]),
+                lane: "PROFLOW_SELF_ITERATION",
+                source: "MONITOR",
+                event: input.event,
+                severity: "INFO",
+                time: now().toISOString(),
+                runRef: {
+                    runId: run.runId,
+                    shiftId: shift.shiftId,
+                    chatRef: shift.chatRef,
+                },
+                summary: input.summary,
+                evidenceRefs: [input.messageRef],
+            },
+            fence: {
+                runId: run.runId,
+                shiftId: shift.shiftId,
+                generation: shift.generation,
+                expectedVersion: run.version,
+                configRevision: config.revision,
+            },
+        });
+        if (!input.deliverNow)
+            return { status: "QUEUED" };
+        try {
+            return await options.monitor.invoke("notification.deliver", {
+                limit: 10,
+            });
+        }
+        catch (error) {
+            return {
+                status: "FAILED",
+                error: error instanceof Error
+                    ? error.message
+                    : "MONITOR_NOTIFICATION_FAILED",
+            };
+        }
+    };
+    const requestBootstrap = async (config, run, shift) => {
+        if (config.projectRef === null)
+            return { state: "PROJECT_BINDING_MISSING" };
+        const observation = parseObservation(await options.monitor.invoke("observation.read", {
+            chatRef: shift.chatRef,
+        }));
+        if (observation.state !== "IDLE")
+            return {
+                state: `BOOTSTRAP_${observation.state}`,
+            };
+        const messageRef = monitorBootstrapMessageRef({
+            runId: run.runId,
+            shiftId: shift.shiftId,
+            generation: shift.generation,
+        });
+        const request = {
+            contract: "execution",
+            contractVersion: "1.0.0",
+            callerRef: "platform-host:monitor-rotation",
+            idempotencyKey: messageRef,
+            capability: "monitor.chat.submit",
+            input: {
+                runId: run.runId,
+                shiftId: shift.shiftId,
+                generation: shift.generation,
+                expectedRunVersion: run.version,
+                configRevision: config.revision,
+                projectRef: config.projectRef,
+                chatRef: shift.chatRef,
+                messageRef,
+                conversationLocator: observation.url,
+                contentFingerprint: messageRef,
+                text: monitorBootstrapText({
+                    runId: run.runId,
+                    shiftId: shift.shiftId,
+                }),
+            },
+        };
+        assertRunning();
+        const result = await options.execution.invoke("executeCapability", request);
+        return appliedExecutionResult(result, "monitor.chat.submit")
+            ? { state: "BOOTSTRAP_DISPATCHED", messageRef }
+            : { state: "BOOTSTRAP_EFFECT_PENDING", messageRef };
+    };
+    const requestTurnWake = async (config, run, shift) => {
+        if (config.projectRef === null)
+            return { state: "PROJECT_BINDING_MISSING" };
+        const observation = parseObservation(await options.monitor.invoke("observation.read", {
+            chatRef: shift.chatRef,
+        }));
+        if (observation.state !== "IDLE")
+            return {
+                state: `ACTIVE_${observation.state}`,
+            };
+        if (!observation.settledRef)
+            return {
+                state: "ACTIVE_IDLE_WITHOUT_SETTLED_REF",
+            };
+        const drivenKey = `${run.runId}:${shift.shiftId}:${shift.generation}`;
+        if (drivenSettledRefs.get(drivenKey) === observation.settledRef)
+            return { state: "ACTIVE_TURN_ALREADY_DRIVEN" };
+        const messageRef = monitorTurnWakeMessageRef({
+            runId: run.runId,
+            shiftId: shift.shiftId,
+            generation: shift.generation,
+            settledRef: observation.settledRef,
+        });
+        const request = {
+            contract: "execution",
+            contractVersion: "1.0.0",
+            callerRef: "platform-host:monitor-rotation",
+            idempotencyKey: messageRef,
+            capability: "monitor.chat.submit",
+            input: {
+                runId: run.runId,
+                shiftId: shift.shiftId,
+                generation: shift.generation,
+                expectedRunVersion: run.version,
+                configRevision: config.revision,
+                projectRef: config.projectRef,
+                chatRef: shift.chatRef,
+                messageRef,
+                conversationLocator: observation.url,
+                contentFingerprint: messageRef,
+                text: monitorTurnWakeText(),
+            },
+        };
+        assertRunning();
+        const result = await options.execution.invoke("executeCapability", request);
+        if (!appliedExecutionResult(result, "monitor.chat.submit"))
+            return { state: "TURN_WAKE_EFFECT_PENDING" };
+        await notifyDrive(config, run, shift, {
+            event: "CHAT_WAKE",
+            messageRef,
+            summary: "Monitor turn drive dispatched.",
+        });
+        drivenSettledRefs.set(drivenKey, observation.settledRef);
+        return {
+            state: "TURN_WAKE_DISPATCHED",
+            messageRef,
+        };
+    };
+    const requestHandoff = async (config, run, shift) => {
+        if (config.projectRef === null)
+            return { state: "PROJECT_BINDING_MISSING" };
+        const observation = parseObservationIdentity(await options.monitor.invoke("observation.read", {
+            chatRef: shift.chatRef,
+        }));
+        const messageRef = monitorHandoffMessageRef({
+            runId: run.runId,
+            shiftId: shift.shiftId,
+            generation: shift.generation,
+        });
+        const request = {
+            contract: "execution",
+            contractVersion: "1.0.0",
+            callerRef: "platform-host:monitor-rotation",
+            idempotencyKey: messageRef,
+            capability: "monitor.chat.submit",
+            input: {
+                runId: run.runId,
+                shiftId: shift.shiftId,
+                generation: shift.generation,
+                expectedRunVersion: run.version,
+                configRevision: config.revision,
+                projectRef: config.projectRef,
+                chatRef: shift.chatRef,
+                messageRef,
+                conversationLocator: observation.url,
+                contentFingerprint: messageRef,
+                text: monitorHandoffRequestText({
+                    runId: run.runId,
+                    shiftId: shift.shiftId,
+                    generation: shift.generation,
+                    projectRef: config.projectRef,
+                }),
+            },
+        };
+        assertRunning();
+        const result = await options.execution.invoke("executeCapability", request);
+        return appliedExecutionResult(result, "monitor.chat.submit")
+            ? { state: "HANDOFF_REQUESTED" }
+            : { state: "HANDOFF_EFFECT_PENDING" };
+    };
+    const createNextChat = async (config, run, shift) => {
+        if (config.projectRef === null ||
+            config.projectLocator === null)
+            return { state: "PROJECT_BINDING_MISSING" };
+        if (!shift.nextChatPromptRef)
+            return { state: "NEXT_CHAT_PROMPT_MISSING" };
+        const prompt = parseArtifact(await options.monitor.invoke("artifact.read", {
+            artifactRef: shift.nextChatPromptRef,
+        }));
+        const nextShiftId = monitorNextShiftId({
+            runId: run.runId,
+            shiftId: shift.shiftId,
+            generation: shift.generation,
+        });
+        const messageRef = monitorNextChatMessageRef({
+            runId: run.runId,
+            shiftId: shift.shiftId,
+            generation: shift.generation,
+            nextShiftId,
+        });
+        const request = {
+            contract: "execution",
+            contractVersion: "1.0.0",
+            callerRef: "platform-host:monitor-rotation",
+            idempotencyKey: messageRef,
+            capability: "monitor.chat.create",
+            input: {
+                runId: run.runId,
+                shiftId: shift.shiftId,
+                generation: shift.generation,
+                expectedRunVersion: run.version,
+                configRevision: config.revision,
+                projectRef: config.projectRef,
+                nextShiftId,
+                messageRef,
+                projectLocator: config.projectLocator,
+                contentFingerprint: messageRef,
+                text: prompt.content,
+            },
+        };
+        assertRunning();
+        const execution = await options.execution.invoke("executeCapability", request);
+        const data = appliedExecutionResult(execution, "monitor.chat.create");
+        if (!data)
+            return { state: "NEXT_CHAT_EFFECT_PENDING" };
+        const chatRef = string(data.chatRef, "MONITOR_NEXT_CHAT_REF");
+        string(data.conversationLocator, "MONITOR_NEXT_CHAT_LOCATOR");
+        assertRunning();
+        const nextRun = parseRun(await options.monitor.invoke("shift.prepareNext", {
+            runId: run.runId,
+            fromShiftId: shift.shiftId,
+            fromGeneration: shift.generation,
+            expectedVersion: run.version,
+            configRevision: config.revision,
+            shiftId: nextShiftId,
+            chatRef,
+        }));
+        return {
+            state: "NEXT_SHIFT_PREPARED",
+            run: nextRun,
+        };
+    };
+    const completeBoot = async (config, run, shift, previous) => {
+        if (!shift.bootProof)
+            return requestBootstrap(config, run, shift);
+        assertRunning();
+        const activated = parseRun(previous
+            ? await options.monitor.invoke("shift.takeover", {
+                runId: run.runId,
+                fromShiftId: previous.shiftId,
+                fromGeneration: previous.generation,
+                toShiftId: shift.shiftId,
+                toGeneration: shift.generation,
+                expectedVersion: run.version,
+                configRevision: config.revision,
+            })
+            : await options.monitor.invoke("shift.activate", {
+                runId: run.runId,
+                shiftId: shift.shiftId,
+                generation: shift.generation,
+                expectedVersion: run.version,
+                configRevision: config.revision,
+            }));
+        return {
+            state: "TAKEOVER_COMPLETED",
+            run: activated,
+        };
+    };
+    const tickRun = async (config, run) => {
+        if (run.activeShiftId) {
+            const active = run.shifts[run.activeShiftId];
+            if (!active || active.state !== "ACTIVE")
+                throw new Error("MONITOR_ACTIVE_SHIFT_INVALID");
+            const status = object(await options.monitor.invoke("shift.rotationStatus", {
+                runId: run.runId,
+                shiftId: active.shiftId,
+            }), "MONITOR_ROTATION_STATUS");
+            if (status.due !== true)
+                return requestTurnWake(config, run, active);
+            const handoffMessageRef = monitorHandoffMessageRef({
+                runId: run.runId,
+                shiftId: active.shiftId,
+                generation: active.generation,
+            });
+            await notifyDrive(config, run, active, {
+                event: "HANDOFF_STARTED",
+                messageRef: handoffMessageRef,
+                summary: "Monitor handoff drive dispatched.",
+                deliverNow: true,
+            });
+            assertRunning();
+            const drained = parseRun(await options.monitor.invoke("shift.beginDrain", {
+                runId: run.runId,
+                shiftId: active.shiftId,
+                generation: active.generation,
+                expectedVersion: run.version,
+                configRevision: config.revision,
+                reason: "ROTATION_DUE",
+            }));
+            const shift = drained.shifts[active.shiftId];
+            if (!shift)
+                throw new Error("MONITOR_DRAINING_SHIFT_MISSING");
+            return requestHandoff(config, drained, shift);
+        }
+        const previous = drainingShift(run);
+        if (previous) {
+            const nextShiftId = monitorNextShiftId({
+                runId: run.runId,
+                shiftId: previous.shiftId,
+                generation: previous.generation,
+            });
+            const next = run.shifts[nextShiftId];
+            if (!previous.handoffRef ||
+                !previous.nextChatPromptRef) {
+                const status = object(await options.monitor.invoke("shift.rotationStatus", {
+                    runId: run.runId,
+                    shiftId: previous.shiftId,
+                }), "MONITOR_ROTATION_STATUS");
+                if (status.expired === true)
+                    return {
+                        state: "HANDOFF_DEADLINE_EXPIRED",
+                    };
+                return requestHandoff(config, run, previous);
+            }
+            if (!next)
+                return createNextChat(config, run, previous);
+            if (next.state !== "BOOTING")
+                return {
+                    state: `NEXT_SHIFT_${next.state}`,
+                };
+            return completeBoot(config, run, next, previous);
+        }
+        const initial = initialBootingShift(run);
+        if (initial)
+            return completeBoot(config, run, initial);
+        return { state: "NO_ACTIVE_ROTATION" };
+    };
+    const tick = async () => {
+        assertRunning();
+        const config = parseConfig(await options.monitor.invoke("config.read", {}));
+        if (!config.enabled)
+            return { state: "DISABLED", runs: [] };
+        if (config.projectRef === null ||
+            config.projectLocator === null)
+            return {
+                state: "PROJECT_BINDING_REQUIRED",
+                runs: [],
+            };
+        const outcomes = [];
+        for (const run of parseRuns(await options.monitor.invoke("run.list", {}))) {
+            assertRunning();
+            try {
+                outcomes.push({
+                    runId: run.runId,
+                    outcome: await tickRun(config, run),
+                });
+            }
+            catch (error) {
+                outcomes.push({
+                    runId: run.runId,
+                    outcome: {
+                        state: "BLOCKED",
+                        error: error instanceof Error
+                            ? error.message
+                            : "MONITOR_ROTATION_FAILED",
+                    },
+                });
+            }
+        }
+        let notification = { status: "DISABLED" };
+        if (config.notificationsEnabled) {
+            try {
+                assertRunning();
+                notification = await options.monitor.invoke("notification.deliver", { limit: 10 });
+            }
+            catch (error) {
+                notification = {
+                    status: "FAILED",
+                    error: error instanceof Error
+                        ? error.message
+                        : "MONITOR_NOTIFICATION_FAILED",
+                };
+            }
+        }
+        return {
+            state: "CHECKED",
+            runs: outcomes,
+            notification,
+        };
+    };
+    const runTick = () => {
+        if (stopping || inFlight)
+            return inFlight;
+        inFlight = tick().finally(() => {
+            inFlight = null;
+        });
+        return inFlight;
+    };
+    const scheduleTick = () => {
+        void runTick()?.catch(async () => {
+            if (stopping)
+                return;
+            try {
+                await options.onError?.("MONITOR_ROTATION_POLL_FAILED");
+            }
+            catch { }
+        });
+    };
+    return Object.freeze({
+        tick,
+        start() {
+            if (timer)
+                return;
+            stopping = false;
+            scheduleTick();
+            timer = setInterval(scheduleTick, intervalMs);
+            timer.unref?.();
+        },
+        async stop() {
+            stopping = true;
+            if (timer)
+                clearInterval(timer);
+            timer = undefined;
+            await inFlight?.catch(() => undefined);
+        },
+    });
+}