@tomflow/proflow-platform-host 0.1.31 → 0.1.32

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @tomflow/proflow-platform-host
 
+## 0.1.32
+
+### Patch Changes
+
+- test(platform-host): align worker provisioning contract
+
 ## 0.1.31
 
 ### Patch Changes

package/dist/deployment/adapter.d.ts

@@ -6,7 +6,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.31";
+            moduleVersion: "0.1.32";
             data: {
                 endpoint: string;
                 stateRoot: string;
@@ -24,7 +24,7 @@ export declare const behaviorAdapter: {
             readonly ok: true;
             readonly status: "SUCCEEDED";
             readonly moduleRef: "platform-host";
-            readonly moduleVersion: "0.1.31";
+            readonly moduleVersion: "0.1.32";
         };
         observedEffects: string[];
     }>;
@@ -34,7 +34,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.31";
+            moduleVersion: "0.1.32";
             data: {
                 setupStatus: "READY";
                 runtimeStatus: "RUNNING" | "STOPPED";
@@ -48,7 +48,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.31";
+            moduleVersion: "0.1.32";
             data: {
                 endpoint: string;
                 stateRoot: string;
@@ -66,7 +66,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.31";
+            moduleVersion: "0.1.32";
             data: {
                 docs: string;
             };
@@ -79,7 +79,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.31";
+            moduleVersion: "0.1.32";
             data: {
                 host: string;
                 port: number;
@@ -90,7 +90,7 @@ export declare const behaviorAdapter: {
         result: {
             contract: "deployment.result.v1";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.31";
+            moduleVersion: "0.1.32";
             ok: false;
             status: "FAILED";
             error: {
@@ -107,7 +107,7 @@ export declare const behaviorAdapter: {
             readonly ok: true;
             readonly status: "SUCCEEDED";
             readonly moduleRef: "platform-host";
-            readonly moduleVersion: "0.1.31";
+            readonly moduleVersion: "0.1.32";
         };
         observedEffects: string[];
     } | {
@@ -116,11 +116,11 @@ export declare const behaviorAdapter: {
             readonly ok: true;
             readonly status: "SUCCEEDED";
             readonly moduleRef: "platform-host";
-            readonly moduleVersion: "0.1.31";
+            readonly moduleVersion: "0.1.32";
         } | {
             contract: "deployment.result.v1";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.31";
+            moduleVersion: "0.1.32";
             ok: false;
             status: "FAILED";
             error: {

package/dist/deployment/descriptor.d.ts

@@ -3,7 +3,7 @@ export declare const descriptor: {
     readonly contractVersion: "1.0.0";
     readonly moduleRef: "platform-host";
     readonly packageName: "@tomflow/proflow-platform-host";
-    readonly moduleVersion: "0.1.31";
+    readonly moduleVersion: "0.1.32";
     readonly kind: "service";
     readonly templateVersion: "1.0.0";
     readonly platformCompatibility: ">=1.0.0 <2.0.0";

package/dist/deployment/descriptor.js

@@ -3,7 +3,7 @@ export const descriptor = {
     contractVersion: "1.0.0",
     moduleRef: "platform-host",
     packageName: "@tomflow/proflow-platform-host",
-    moduleVersion: "0.1.31",
+    moduleVersion: "0.1.32",
     kind: "service",
     templateVersion: "1.0.0",
     platformCompatibility: ">=1.0.0 <2.0.0",

package/dist/src/index.js

@@ -7,6 +7,7 @@ import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { createAgentRuntime } from "@tomflow/proflow-agent-runtime";
 import { createMonitorControlClient, } from "@tomflow/proflow-execution-browser-extension";
 import { createLocalToolBridgeHostClient, LocalToolBridgeError, } from "@tomflow/proflow-execution-browser-extension/local-tool-bridge";
+import { browserActionInputSchema, parseMonitorEffectRequest } from "@tomflow/proflow-execution-contracts";
 import { applyMigrations } from "@tomflow/proflow-task-migration-runner";
 import { createTaskServices, publicOperationNames, } from "@tomflow/proflow-task-orchestration";
 import { SqliteTaskStore } from "@tomflow/proflow-task-store-sqlite";
@@ -14,7 +15,8 @@ import { taskMigrations } from "@tomflow/proflow-task-store-sqlite/migrations";
 import { z } from "zod";
 import { resolveBrowserPermissionTaskBinding } from "./browser-permission-context.js";
 import { classifyBrowserPermission, } from "./browser-permission-policy.js";
-import { authorizeMonitorExecution, createMonitorRotationCoordinator, } from "./monitor-rotation-coordinator.js";
+import { authorizeMonitorExecution } from "./monitor-rotation-coordinator.js";
+import { createMonitorDriveRelay } from "./monitor-drive-relay.js";
 import { canonicalizeProductOperation, createProductCampaignContinuationCoordinator, } from "./product-campaign-continuation.js";
 import { createProductDiscussionHost } from "./product-discussion-host.js";
 import { createReconciliationCoordinator } from "./reconciliation-coordinator.js";
@@ -276,6 +278,8 @@ function createOwnerHttpClient(owner, baseUrl, credential, resolveConnection, sh
             }
             else if (operationId === "materializeExternalFiles")
                 path = "/external-files/materialize";
+            else if (operationId === "effect.execute")
+                path = "/effects/execute";
             else if (operationId === "executeCapability")
                 path = "/executions";
             else if (operationId === "lookupExecutionIntent")
@@ -334,8 +338,8 @@ function createOwnerHttpClient(owner, baseUrl, credential, resolveConnection, sh
                     ? { body: JSON.stringify(requestBody) }
                     : {}),
                 signal: shutdownSignal
-                    ? AbortSignal.any([shutdownSignal, AbortSignal.timeout(OWNER_INVOKE_WATCHDOG_MS)])
-                    : AbortSignal.timeout(OWNER_INVOKE_WATCHDOG_MS),
+                    ? AbortSignal.any([shutdownSignal, AbortSignal.timeout(operationId === "effect.execute" ? 190_000 : OWNER_INVOKE_WATCHDOG_MS)])
+                    : AbortSignal.timeout(operationId === "effect.execute" ? 190_000 : OWNER_INVOKE_WATCHDOG_MS),
             }));
         },
     });
@@ -477,21 +481,11 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             },
         })
         : undefined;
+    const monitorDriveRelay = monitor
+        ? createMonitorDriveRelay({ monitor, execution })
+        : undefined;
     let reconciliationCoordinator;
     let productCampaignContinuationCoordinator;
-    const monitorRotationCoordinator = monitor
-        ? createMonitorRotationCoordinator({
-            monitor,
-            execution,
-            onError: (errorCode) => sink.write("platform-host", {
-                timestamp: new Date().toISOString(),
-                level: "WARN",
-                component: "platform-host-monitor-rotation",
-                event: "MONITOR_ROTATION_POLL_FAILED",
-                errorCode,
-            }),
-        })
-        : undefined;
     const boundedSystemView = async (view) => {
         if (view === "task") {
             const tasks = unwrap(task.queries.listTasks({})).tasks;
@@ -869,6 +863,30 @@ async function constructGraph(config, executionCredential, modelCredential, reso
     });
     const authorizeExecution = async (request) => {
         try {
+            if (request.capability === "browser.action") {
+                if (request.callerRef !== "platform-host:browser-action")
+                    return false;
+                const input = browserActionInputSchema.parse(request.input);
+                // Authenticated local Action owner; reload must also work before Monitor initialization.
+                if (input.kind === "RELOAD")
+                    return true;
+                if (!monitor)
+                    return false;
+                const state = object(await monitor.invoke("state.read", {}), "monitor state");
+                const chats = object(state.chats, "monitor chats");
+                const config = object(state.config, "monitor config");
+                const allowed = new Set(Object.values(chats).flatMap((chat) => {
+                    if (!chat || typeof chat !== "object" || !("conversationLocator" in chat) ||
+                        typeof chat.conversationLocator !== "string")
+                        return [];
+                    return [chat.conversationLocator];
+                }));
+                if (typeof config.projectLocator === "string")
+                    allowed.add(config.projectLocator);
+                allowed.add("chrome://extensions/?id=eehdadpmjffomabiedcjijiakconalab");
+                allowed.add("chrome://extensions/?errors=eehdadpmjffomabiedcjijiakconalab");
+                return input.targets.every((target) => allowed.has(target.url));
+            }
             if (request.capability === "product.discussion.bootstrap.deliver")
                 return productDiscussionHost
                     ? productDiscussionHost.authorizeBootstrapExecution(request)
@@ -877,7 +895,15 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                 request.capability === "monitor.chat.create") {
                 if (!monitor)
                     return false;
-                return authorizeMonitorExecution({ monitor, request: request });
+                if (request.callerRef === "platform-host:monitor-drive") {
+                    const authorization = object(await monitor.invoke("drive.authorize", { request }), "monitor drive authorization");
+                    return authorization.authorized === true;
+                }
+                // Transitional compatibility until legacy Monitor lifecycle code is removed.
+                return authorizeMonitorExecution({
+                    monitor,
+                    request: request,
+                });
             }
             if (request.capability === "product.review.deliver") {
                 if (request.callerRef !== "platform-host:campaign-continuation")
@@ -1477,6 +1503,20 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                 throw new Error(`PRODUCT_REVIEW_DELIVERY_NOT_CONFIRMED:${status}:${sideEffectState}`);
         },
     });
+    const monitorApplication = observer.port("monitor", {
+        async invoke(operation, rawInput) {
+            object(rawInput, "monitor application input");
+            if (operation === "effect.execute") {
+                parseMonitorEffectRequest(rawInput);
+                return execution.invoke("effect.execute", rawInput);
+            }
+            if (operation !== "drive")
+                throw new Error("UNSUPPORTED_MONITOR_APPLICATION_OPERATION");
+            if (!monitorDriveRelay)
+                throw new Error("MONITOR_CONTROL_UNAVAILABLE");
+            return monitorDriveRelay.drive();
+        },
+    });
     const taskApplication = observer.port("task", {
         async invoke(operation, rawInput) {
             const value = object(rawInput, "task application input");
@@ -1794,9 +1834,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
         taskApplication,
         approvalApplication,
         observerApplication,
-        startMonitorRotation() {
-            monitorRotationCoordinator?.start();
-        },
+        monitorApplication,
         async lookup(_operationId, _authenticatedRoleRef, _input) {
             throw Object.assign(new Error("ACTION_RESULT_LOOKUP_UNSUPPORTED"), { httpStatus: 409 });
         },
@@ -1829,7 +1867,6 @@ async function constructGraph(config, executionCredential, modelCredential, reso
         async close() {
             productCampaignContinuationCoordinator?.stop();
             reconciliationCoordinator?.stop();
-            await monitorRotationCoordinator?.stop();
             ownerShutdown.abort();
             await Promise.all([
                 productCampaignContinuationCoordinator?.drain(),
@@ -2166,6 +2203,36 @@ export function createPlatformHost(input) {
                                 });
                             }
                         }
+                        if (request.method === "POST" && url.pathname === "/application/monitor") {
+                            if (!taskApplicationCredential ||
+                                !managementCredentialMatches(request.headers.authorization, taskApplicationCredential))
+                                return respond(response, 401, {
+                                    error: "MONITOR_APPLICATION_AUTH_FAILED",
+                                });
+                            const chunks = [];
+                            let bytes = 0;
+                            for await (const chunk of request) {
+                                const buffer = Buffer.isBuffer(chunk)
+                                    ? chunk
+                                    : Buffer.from(chunk);
+                                bytes += buffer.byteLength;
+                                if (bytes > 65_536)
+                                    throw new TypeError("REQUEST_BODY_TOO_LARGE");
+                                chunks.push(buffer);
+                            }
+                            const body = object(JSON.parse(Buffer.concat(chunks).toString("utf8")), "monitor application request");
+                            try {
+                                const result = await graph.monitorApplication.invoke(string(body.operation, "operation"), body.input ?? {});
+                                return respond(response, 200, result);
+                            }
+                            catch (error) {
+                                return respond(response, 400, {
+                                    error: error instanceof Error
+                                        ? error.message
+                                        : "INVALID_REQUEST",
+                                });
+                            }
+                        }
                         if (request.method === "POST" && url.pathname === "/application/observer") {
                             if (!taskApplicationCredential ||
                                 !managementCredentialMatches(request.headers.authorization, taskApplicationCredential))
@@ -2296,7 +2363,6 @@ export function createPlatformHost(input) {
             const address = server.address();
             if (!address || typeof address === "string")
                 throw new Error("platform-host missing TCP address");
-            graph.startMonitorRotation();
             log("SERVICE_STARTED", { host: input.config.host, port: address.port });
             return { host: input.config.host, port: address.port };
         }

package/dist/src/monitor-drive-relay.d.ts

@@ -0,0 +1,13 @@
+type MonitorPort = {
+    invoke(operation: string, input?: unknown): Promise<unknown>;
+};
+type ExecutionPort = {
+    invoke(operation: string, input: unknown): Promise<unknown>;
+};
+export declare function createMonitorDriveRelay(options: {
+    monitor: MonitorPort;
+    execution: ExecutionPort;
+}): Readonly<{
+    drive(): Promise<unknown>;
+}>;
+export {};

package/dist/src/monitor-drive-relay.js

@@ -0,0 +1,107 @@
+import { parseExecuteCapabilityRequest, parseMonitorEffectReceipt, } from "@tomflow/proflow-execution-contracts";
+function record(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 capability(value) {
+    if (value !== "monitor.chat.submit" && value !== "monitor.chat.create")
+        throw new Error("MONITOR_DRIVE_CAPABILITY_INVALID");
+    return value;
+}
+function parsePlan(value) {
+    if (value === null)
+        return null;
+    const raw = record(value, "MONITOR_DRIVE_PLAN");
+    return {
+        driveId: string(raw.driveId, "MONITOR_DRIVE_ID"),
+        capability: capability(raw.capability),
+        idempotencyKey: string(raw.idempotencyKey, "MONITOR_DRIVE_IDEMPOTENCY_KEY"),
+        request: record(raw.request, "MONITOR_DRIVE_REQUEST"),
+    };
+}
+export function createMonitorDriveRelay(options) {
+    let inFlight = null;
+    const driveOnce = async () => {
+        const plan = parsePlan(await options.monitor.invoke("drive.next", {}));
+        if (!plan) {
+            let notificationDelivery = "SETTLED";
+            try {
+                await options.monitor.invoke("notification.deliver", { limit: 10 });
+            }
+            catch {
+                notificationDelivery = "FAILED";
+            }
+            return { state: "IDLE", notificationDelivery };
+        }
+        if (plan.driveId !== plan.idempotencyKey)
+            throw new Error("MONITOR_EFFECT_IDENTITY_MISMATCH");
+        const request = parseExecuteCapabilityRequest({
+            contract: "execution",
+            contractVersion: "1.0.0",
+            callerRef: "platform-host:monitor-drive",
+            idempotencyKey: plan.idempotencyKey,
+            capability: plan.capability,
+            input: plan.request,
+        });
+        const authorization = record(await options.monitor.invoke("drive.authorize", { request }), "MONITOR_DRIVE_AUTHORIZATION");
+        if (authorization.authorized !== true)
+            throw new Error("MONITOR_DRIVE_NOT_AUTHORIZED");
+        let execution;
+        try {
+            execution = await options.execution.invoke("effect.execute", { effectId: plan.driveId, action: plan.capability, payload: plan.request });
+        }
+        catch {
+            // The effect may already be durable or applied. Preserve the pending
+            // drive; a later trigger reads the same durable effect; PENDING never replays.
+            return {
+                state: "PENDING",
+                driveId: plan.driveId,
+                errorCode: "EXECUTION_OWNER_RESPONSE_UNKNOWN",
+            };
+        }
+        const executionRecord = parseMonitorEffectReceipt(execution);
+        if (executionRecord.effectId !== plan.driveId || executionRecord.action !== plan.capability)
+            throw new Error("MONITOR_EFFECT_IDENTITY_MISMATCH");
+        let settlement;
+        try {
+            settlement = record(await options.monitor.invoke("drive.result", {
+                driveId: plan.driveId, execution: executionRecord,
+            }), "MONITOR_DRIVE_SETTLEMENT");
+        }
+        catch {
+            return { state: "PENDING", driveId: plan.driveId,
+                errorCode: "MONITOR_SETTLEMENT_RESPONSE_LOST" };
+        }
+        let notificationDelivery = "SETTLED";
+        try {
+            await options.monitor.invoke("notification.deliver", { limit: 10 });
+        }
+        catch {
+            notificationDelivery = "FAILED";
+        }
+        return {
+            state: string(settlement.state, "MONITOR_DRIVE_SETTLEMENT_STATE"),
+            driveId: plan.driveId,
+            ...(typeof executionRecord.executionRef === "string"
+                ? { executionRef: executionRecord.executionRef }
+                : {}),
+            notificationDelivery,
+        };
+    };
+    return Object.freeze({
+        drive() {
+            if (inFlight)
+                return inFlight;
+            inFlight = driveOnce().finally(() => {
+                inFlight = null;
+            });
+            return inFlight;
+        },
+    });
+}

package/dist/src/monitor-rotation-coordinator.d.ts

@@ -2,75 +2,12 @@ import type { ExecuteCapabilityRequest } from "@tomflow/proflow-execution-contra
 export type MonitorControlPort = {
     invoke(operation: string, input?: unknown): Promise<unknown>;
 };
-export type MonitorExecutionPort = {
-    invoke(operation: string, input: unknown): Promise<unknown>;
-};
-export declare function monitorHandoffMessageRef(input: {
-    runId: string;
-    shiftId: string;
-    generation: number;
-}): string;
-export declare function monitorBootstrapMessageRef(input: {
-    runId: string;
-    shiftId: string;
-    generation: number;
-}): string;
-export declare function monitorBootstrapText(input: {
-    runId: string;
-    shiftId: string;
-}): string;
-export declare function monitorTurnWakeMessageRef(input: {
-    runId: string;
-    shiftId: string;
-    generation: number;
-    settledRef: string;
-}): string;
-export declare function monitorTurnWakeText(): string;
-export declare function monitorNextShiftId(input: {
-    runId: string;
-    shiftId: string;
-    generation: number;
-}): string;
-export declare function monitorNextChatMessageRef(input: {
-    runId: string;
-    shiftId: string;
-    generation: number;
-    nextShiftId: string;
-}): string;
-export declare function monitorHandoffRequestText(_input: {
-    runId: string;
-    shiftId: string;
-    generation: number;
-    projectRef: string;
-}): string;
+/**
+ * Transitional symbol retained only while Platform Host still imports it.
+ * The legacy polling/rotation coordinator is removed: Browser timing asks the
+ * Node owner for a concrete drive, and Node is the only authorization owner.
+ */
 export declare function authorizeMonitorExecution(input: {
     monitor: MonitorControlPort;
     request: ExecuteCapabilityRequest;
-    now?: () => Date;
 }): Promise<boolean>;
-export declare function createMonitorRotationCoordinator(options: {
-    monitor: MonitorControlPort;
-    execution: MonitorExecutionPort;
-    intervalMs?: number;
-    now?: () => Date;
-    onError?: (code: "MONITOR_ROTATION_POLL_FAILED") => void | Promise<void>;
-}): Readonly<{
-    tick: () => Promise<{
-        state: "DISABLED";
-        runs: never[];
-        notification?: never;
-    } | {
-        state: "PROJECT_BINDING_REQUIRED";
-        runs: never[];
-        notification?: never;
-    } | {
-        state: "CHECKED";
-        runs: {
-            runId: string;
-            outcome: unknown;
-        }[];
-        notification: unknown;
-    }>;
-    start(): void;
-    stop(): Promise<void>;
-}>;

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

@@ -1,782 +1,24 @@
-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");
-}
+/**
+ * Transitional symbol retained only while Platform Host still imports it.
+ * The legacy polling/rotation coordinator is removed: Browser timing asks the
+ * Node owner for a concrete drive, and Node is the only authorization owner.
+ */
 export async function authorizeMonitorExecution(input) {
     try {
-        const request = input.request;
-        if (!monitorCapability(request))
+        if (input.request.capability !== "monitor.chat.submit" &&
+            input.request.capability !== "monitor.chat.create")
             return false;
-        if (request.callerRef !== "platform-host:monitor-rotation")
+        if (input.request.callerRef !== "platform-host:monitor-drive")
             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 value = await input.monitor.invoke("drive.authorize", {
+            request: input.request,
         });
-        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;
+        return (typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value) &&
+            Reflect.get(value, "authorized") === true);
     }
     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);
-        },
-    });
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomflow/proflow-platform-host",
-  "version": "0.1.31",
+  "version": "0.1.32",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -24,19 +24,19 @@
   ],
   "dependencies": {
     "zod": "4.1.12",
-    "@tomflow/proflow-agent-runtime": "^0.1.17",
+    "@tomflow/proflow-agent-runtime": "^0.1.18",
     "@tomflow/proflow-module-contract": "^0.1.13",
-    "@tomflow/proflow-execution-contracts": "^0.1.11",
-    "@tomflow/proflow-execution-browser-extension": "^0.1.65",
-    "@tomflow/proflow-task-store-sqlite": "^0.1.12",
     "@tomflow/proflow-task-migration-runner": "^0.1.11",
-    "@tomflow/proflow-task-orchestration": "^0.1.12"
+    "@tomflow/proflow-execution-browser-extension": "^0.1.74",
+    "@tomflow/proflow-execution-contracts": "^0.1.12",
+    "@tomflow/proflow-task-orchestration": "^0.1.12",
+    "@tomflow/proflow-task-store-sqlite": "^0.1.12"
   },
   "devDependencies": {
-    "@tomflow/proflow-execution-runtime": "^0.1.19",
-    "@tomflow/proflow-deployment-conformance": "^0.1.13",
     "@tomflow/proflow-agent-gateway": "^0.1.19",
-    "@tomflow/proflow-model-runtime": "^0.1.26"
+    "@tomflow/proflow-execution-runtime": "^0.1.20",
+    "@tomflow/proflow-model-runtime": "^0.1.26",
+    "@tomflow/proflow-deployment-conformance": "^0.1.13"
   },
   "description": "Provides the ProFlow local application composition root that binds Task, Agent, Execution and Model owner transports.",
   "keywords": [

package/proflow.module.json

@@ -3,7 +3,7 @@
 	"contractVersion": "1.0.0",
 	"moduleRef": "platform-host",
 	"packageName": "@tomflow/proflow-platform-host",
-	"moduleVersion": "0.1.31",
+	"moduleVersion": "0.1.32",
 	"kind": "service",
 	"templateVersion": "1.0.0",
 	"platformCompatibility": ">=1.0.0 <2.0.0",