@tomflow/proflow-platform-host 0.1.30 → 0.1.31

package/dist/src/index.js

@@ -5,6 +5,7 @@ import { chmod, mkdir, readFile, stat, writeFile, } from "node:fs/promises";
 import { createServer } from "node:http";
 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 { applyMigrations } from "@tomflow/proflow-task-migration-runner";
 import { createTaskServices, publicOperationNames, } from "@tomflow/proflow-task-orchestration";
@@ -13,10 +14,23 @@ 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 { canonicalizeProductOperation, createProductCampaignContinuationCoordinator, } from "./product-campaign-continuation.js";
+import { createProductDiscussionHost } from "./product-discussion-host.js";
 import { createReconciliationCoordinator } from "./reconciliation-coordinator.js";
 import { directToolActionIds, roleAllowsDirectToolOperation, roleOperations, rolePackageRefs, } from "./role-operations.js";
 const loopbackHosts = new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
 const OWNER_INVOKE_WATCHDOG_MS = 120_000;
+const productCampaignOperationIds = new Set([
+    "getProductCampaign",
+    "getProductDiscussionContext",
+    "getProductDocument",
+    "putProductDocument",
+    "getCampaignAuthorization",
+    "submitProductTaskIntent",
+    "recordProductGapReview",
+    "recordProductGoalSatisfied",
+]);
 const systemObserverReasonResultSchema = z
     .object({
     scope: z.string().min(1).max(240).optional(),
@@ -207,7 +221,7 @@ async function responseJson(response) {
         });
     return value;
 }
-function createOwnerHttpClient(owner, baseUrl, credential, resolveConnection) {
+function createOwnerHttpClient(owner, baseUrl, credential, resolveConnection, shutdownSignal) {
     const connection = async () => {
         const resolved = resolveConnection
             ? await resolveConnection(owner)
@@ -319,7 +333,9 @@ function createOwnerHttpClient(owner, baseUrl, credential, resolveConnection) {
                 ...(method === "POST"
                     ? { body: JSON.stringify(requestBody) }
                     : {}),
-                signal: AbortSignal.timeout(OWNER_INVOKE_WATCHDOG_MS),
+                signal: shutdownSignal
+                    ? AbortSignal.any([shutdownSignal, AbortSignal.timeout(OWNER_INVOKE_WATCHDOG_MS)])
+                    : AbortSignal.timeout(OWNER_INVOKE_WATCHDOG_MS),
             }));
         },
     });
@@ -382,7 +398,7 @@ async function readDeploymentOwnerSummary(stateRoot) {
         return undefined;
     }
 }
-async function constructGraph(config, executionCredential, modelCredential, resolveConnection, resolveLocalToolConnection) {
+async function constructGraph(config, executionCredential, modelCredential, resolveConnection, resolveLocalToolConnection, resolveMonitorControlConnection) {
     const sink = createOperationSink(config.stateRoot);
     const observer = createHostOperationObserver(entry => sink.write("platform-host", entry));
     const databasePath = join(config.stateRoot, "state", "task.sqlite");
@@ -445,9 +461,37 @@ async function constructGraph(config, executionCredential, modelCredential, reso
         taskStore.close();
         throw error;
     }
-    const execution = observer.port("execution", createOwnerHttpClient("execution", config.executionBaseUrl, executionCredential, resolveConnection));
-    const model = observer.port("model", createOwnerHttpClient("model", config.modelBaseUrl, modelCredential, resolveConnection));
+    const ownerShutdown = new AbortController();
+    const execution = observer.port("execution", createOwnerHttpClient("execution", config.executionBaseUrl, executionCredential, resolveConnection, ownerShutdown.signal));
+    const model = observer.port("model", createOwnerHttpClient("model", config.modelBaseUrl, modelCredential, resolveConnection, ownerShutdown.signal));
+    const monitor = resolveMonitorControlConnection
+        ? Object.freeze({
+            async invoke(operation, input = {}) {
+                const connection = await resolveMonitorControlConnection();
+                if (!connection)
+                    throw new Error("MONITOR_CONTROL_UNAVAILABLE");
+                return createMonitorControlClient({
+                    endpoint: connection.endpoint,
+                    token: connection.credential,
+                }).invoke(operation, input);
+            },
+        })
+        : 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;
@@ -649,8 +693,59 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                 throw Object.assign(new Error(code), { httpStatus });
             }
         }
-        const taskOperation = taskOperations.get(operationId);
+        const taskOperation = operationId === "getProductDiscussionContext"
+            ? () => {
+                const session = agent.getProductDiscussionSession(string(input.discussionRef, "discussionRef"));
+                return { ok: true, data: { ...session, discussionGeneration: session.generation } };
+            }
+            : taskOperations.get(operationId);
         if (taskOperation) {
+            const productOperation = role.agentPackageRef === "@tomflow/proflow-agent-product" &&
+                productCampaignOperationIds.has(operationId)
+                ? canonicalizeProductOperation({
+                    operationId,
+                    authenticatedRoleRef,
+                    rawInput: input,
+                    getDiscussionSession: (discussionRef) => agent.getProductDiscussionSession(discussionRef),
+                    getRoleBindings: () => rolePackageRefs.map((agentPackageRef) => ({
+                        agentPackageRef,
+                        roleRef: roleForPackage(agentPackageRef).roleRef,
+                    })),
+                    verifyDiscussionAdmission: (admission) => {
+                        if (!productDiscussionHost?.verifyAdmission(admission))
+                            return false;
+                        return !unwrap(task.queries.listTasks({})).tasks.some((summary) => unwrap(task.queries.getTask({ taskId: summary.taskId })).roleBindings.some((binding) => binding.conversationLocator === admission.conversationLocator ||
+                            binding.workerRef === admission.conversationRef));
+                    },
+                })
+                : undefined;
+            if (productOperation?.scope === "PRODUCT_QUERY") {
+                if (operationId === "getCampaignAuthorization") {
+                    const authorization = unwrap(task.queries.getCampaignAuthorization(productOperation.input));
+                    if (authorization.campaignRef !== input.campaignRef ||
+                        authorization.discussionRef !== input.discussionRef)
+                        throw Object.assign(new Error("PRODUCT_DISCUSSION_CAMPAIGN_MISMATCH"), { httpStatus: 403 });
+                }
+                return taskOperation(productOperation.input);
+            }
+            if (productOperation?.scope === "PRODUCT_MUTATION") {
+                const taskResult = await taskOperation({
+                    ...productOperation.input,
+                    actorRef: productOperation.actorRef,
+                });
+                if (productOperation.kickContinuation &&
+                    typeof taskResult === "object" &&
+                    taskResult !== null &&
+                    Reflect.get(taskResult, "ok") === true) {
+                    const data = Reflect.get(taskResult, "data");
+                    if (typeof data === "object" && data !== null) {
+                        const taskId = Reflect.get(data, "taskId");
+                        if (typeof taskId === "string")
+                            productCampaignContinuationCoordinator?.kick(taskId);
+                    }
+                }
+                return taskResult;
+            }
             let actorRef = authenticatedRoleRef;
             let canonicalWorkerRef;
             if (typeof input.taskId === "string") {
@@ -691,8 +786,10 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             const taskResult = await taskOperation(queryOperations.has(operationId)
                 ? canonicalTaskInput
                 : { ...canonicalTaskInput, actorRef });
-            if (taskMutationOperations.has(operationId) && typeof input.taskId === "string")
+            if (taskMutationOperations.has(operationId) && typeof input.taskId === "string") {
                 reconciliationCoordinator?.kick(input.taskId);
+                productCampaignContinuationCoordinator?.kick(input.taskId);
+            }
             if (operationId === "getTaskDocument")
                 return fileBridgeOutputForTaskResult(taskResult);
             return taskResult;
@@ -713,8 +810,14 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                 const declared = current.roleBindings.find((item) => item.roleRef === binding.roleRef);
                 if (!declared)
                     throw new Error("AGENT_PACKAGE_NOT_ELIGIBLE");
-                if (declared.workerRef === binding.workerRef)
+                if (declared.workerRef === binding.workerRef) {
+                    if (declared.conversationLocator !== null &&
+                        declared.conversationLocator !== binding.conversationLocator)
+                        throw new Error("TASK_ROLE_BINDING_CONVERSATION_MISMATCH");
+                    if (declared.conversationLocator === binding.conversationLocator)
+                        productDiscussionHost?.releaseTaskWorker(binding.taskId, binding.roleRef);
                     return;
+                }
                 if (declared.workerRef)
                     throw new Error("TASK_ROLE_BINDING_CONFLICT");
                 unwrap(task.commands.bindTaskWorker({
@@ -727,7 +830,9 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                     actorRef: "platform-host:worker-provisioning",
                     idempotencyKey: `browser-bind:${binding.taskId}:${binding.roleRef}:${binding.workerRef}`,
                 }));
+                productDiscussionHost?.releaseTaskWorker(binding.taskId, binding.roleRef);
                 reconciliationCoordinator?.kick(binding.taskId);
+                productCampaignContinuationCoordinator?.kick(binding.taskId);
             },
         }),
         agent: Object.freeze({
@@ -764,6 +869,62 @@ async function constructGraph(config, executionCredential, modelCredential, reso
     });
     const authorizeExecution = async (request) => {
         try {
+            if (request.capability === "product.discussion.bootstrap.deliver")
+                return productDiscussionHost
+                    ? productDiscussionHost.authorizeBootstrapExecution(request)
+                    : false;
+            if (request.capability === "monitor.chat.submit" ||
+                request.capability === "monitor.chat.create") {
+                if (!monitor)
+                    return false;
+                return authorizeMonitorExecution({ monitor, request: request });
+            }
+            if (request.capability === "product.review.deliver") {
+                if (request.callerRef !== "platform-host:campaign-continuation")
+                    return false;
+                if (request.taskId !== undefined ||
+                    request.nodeId !== undefined ||
+                    request.runNo !== undefined ||
+                    request.workerRef !== undefined ||
+                    request.projectRoot !== undefined)
+                    return false;
+                const reviewInput = object(request.input, "product review execution input");
+                const reviewRef = string(reviewInput.reviewRef, "input.reviewRef");
+                const discussionRef = string(reviewInput.discussionRef, "input.discussionRef");
+                const discussionGeneration = positiveInteger(reviewInput.discussionGeneration, "input.discussionGeneration");
+                const roleRef = string(reviewInput.roleRef, "input.roleRef");
+                const conversationRef = string(reviewInput.conversationRef, "input.conversationRef");
+                const conversationLocator = string(reviewInput.conversationLocator, "input.conversationLocator");
+                const campaignRef = string(reviewInput.campaignRef, "input.campaignRef");
+                const intentRef = string(reviewInput.intentRef, "input.intentRef");
+                const terminalTaskId = string(reviewInput.terminalTaskId, "input.terminalTaskId");
+                const terminalTaskVersion = positiveInteger(reviewInput.terminalTaskVersion, "input.terminalTaskVersion");
+                if (request.roleRef !== roleRef)
+                    return false;
+                const productRole = agent
+                    .listRegisteredRoles()
+                    .find((candidate) => candidate.agentPackageRef === "@tomflow/proflow-agent-product");
+                if (!productRole || productRole.roleRef !== roleRef)
+                    return false;
+                const session = agent.getProductDiscussionSession(discussionRef);
+                if (session.status !== "ACTIVE" ||
+                    session.roleRef !== roleRef ||
+                    session.generation !== discussionGeneration ||
+                    session.conversationRef !== conversationRef ||
+                    session.conversationLocator !== conversationLocator ||
+                    session.campaignRef !== campaignRef ||
+                    session.currentIntentRef !== intentRef)
+                    return false;
+                const terminalTask = unwrap(task.queries.getTask({ taskId: terminalTaskId }));
+                if (!taskIsTerminal(terminalTask.status) ||
+                    terminalTask.version !== terminalTaskVersion)
+                    return false;
+                const expectedReviewRef = `product-review:${campaignRef}:${terminalTaskId}:${terminalTaskVersion}:${discussionRef}:${discussionGeneration}`;
+                if (reviewRef !== expectedReviewRef ||
+                    reviewInput.contentFingerprint !== expectedReviewRef)
+                    return false;
+                return true;
+            }
             const browserCapability = request.capability === "worker.create" ||
                 request.capability === "worker.restore" ||
                 request.capability === "worker.wake" ||
@@ -908,6 +1069,29 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             throw new Error("ROLE_NOT_FOUND");
         return role;
     };
+    const productRole = agent
+        .listRegisteredRoles()
+        .find((candidate) => candidate.agentPackageRef === "@tomflow/proflow-agent-product");
+    const productDiscussionHost = productRole
+        ? createProductDiscussionHost({
+            productRoleRef: productRole.roleRef,
+            listTaskIds: () => unwrap(task.queries.listTasks({})).tasks.map((summary) => summary.taskId),
+            getTaskFact: (taskId) => {
+                const current = unwrap(task.queries.getTask({ taskId }));
+                return {
+                    taskId: current.taskId,
+                    status: current.status,
+                    roleBindings: current.roleBindings,
+                };
+            },
+            registerDiscussionSession: (input) => agent.registerProductDiscussionSession(input),
+            getDiscussionSession: (discussionRef) => agent.getProductDiscussionSession(discussionRef),
+            async executeCapability(request) {
+                return execution.invoke("executeCapability", request);
+            },
+        })
+        : undefined;
+    await productDiscussionHost?.recoverReservations();
     const browserPermissionRole = (roleRef) => {
         const role = agent.listRegisteredRoles().find((candidate) => candidate.roleRef === roleRef);
         if (!role || !rolePackageRefs.includes(role.agentPackageRef))
@@ -953,6 +1137,49 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             }
             if (operation === "role.list")
                 return agent.listRegisteredRoles();
+            if (operation === "product.campaign.authorize") {
+                const discussionRef = string(value.discussionRef, "discussionRef");
+                const campaignRef = string(value.campaignRef, "campaignRef");
+                const goalRevision = positiveInteger(value.goalRevision, "goalRevision");
+                const productRole = roleForPackage("@tomflow/proflow-agent-product");
+                const before = agent.getProductDiscussionSession(discussionRef);
+                if (before.status !== "ACTIVE" || before.roleRef !== productRole.roleRef)
+                    throw new Error("PRODUCT_DISCUSSION_SESSION_NOT_READY");
+                const granted = unwrap(task.commands.createCampaignAuthorization({
+                    ...(value.authorizationRef === undefined
+                        ? {}
+                        : { authorizationRef: string(value.authorizationRef, "authorizationRef") }),
+                    campaignRef,
+                    discussionRef,
+                    goalRevision,
+                    goalSummary: string(value.goalSummary, "goalSummary"),
+                    scope: value.scope,
+                    constraints: value.constraints,
+                    actorRef: "trusted:product-control",
+                    idempotencyKey: string(value.idempotencyKey, "idempotencyKey"),
+                }));
+                const current = agent.getProductDiscussionSession(discussionRef);
+                if (current.status !== "ACTIVE" || current.roleRef !== productRole.roleRef)
+                    throw new Error("PRODUCT_DISCUSSION_SESSION_NOT_READY");
+                const discussionSession = current.campaignRef === campaignRef &&
+                    current.goalRevision === goalRevision
+                    ? current
+                    : agent.updateProductDiscussionSessionContext({
+                        discussionRef,
+                        expectedVersion: current.version,
+                        campaignRef,
+                        goalRevision,
+                    });
+                return { ...granted, discussionSession };
+            }
+            if (operation === "product.campaign.revoke")
+                return unwrap(task.commands.revokeCampaignAuthorization({
+                    authorizationRef: string(value.authorizationRef, "authorizationRef"),
+                    expectedAuthorizationVersion: positiveInteger(value.expectedAuthorizationVersion, "expectedAuthorizationVersion"),
+                    reason: string(value.reason, "reason"),
+                    actorRef: "trusted:product-control",
+                    idempotencyKey: string(value.idempotencyKey, "idempotencyKey"),
+                }));
             const agentPackageRef = string(value.agentPackageRef, "agentPackageRef");
             const role = roleForPackage(agentPackageRef);
             if (operation === "role.show")
@@ -989,9 +1216,12 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             const binding = current.roleBindings.find((candidate) => candidate.agentPackageRef === agentPackageRef);
             if (!binding)
                 throw new Error("TASK_ROLE_BINDING_REQUIRED");
-            if (binding.workerRef && binding.conversationLocator)
+            if (binding.workerRef && binding.conversationLocator) {
+                productDiscussionHost?.releaseTaskWorker(taskId, binding.roleRef);
                 return;
+            }
             const role = roleForPackage(agentPackageRef);
+            productDiscussionHost?.reserveTaskWorker(taskId, role.roleRef);
             const executionRecord = object(await execution.invoke("executeCapability", {
                 contract: "execution",
                 contractVersion: "1.0.0",
@@ -1007,12 +1237,18 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                     bootstrapFingerprint: `new-task:${taskId}:${agentPackageRef}`,
                 },
             }), "worker create execution");
-            if (executionRecord.status !== "SUCCEEDED")
+            if (executionRecord.status !== "SUCCEEDED") {
+                current = unwrap(task.queries.getTask({ taskId }));
+                const observed = current.roleBindings.find((candidate) => candidate.agentPackageRef === agentPackageRef);
+                if (observed?.workerRef && observed.conversationLocator)
+                    productDiscussionHost?.releaseTaskWorker(taskId, observed.roleRef);
                 throw new Error(`WORKER_CREATE_NOT_CONFIRMED:${String(executionRecord.status)}`);
+            }
             current = unwrap(task.queries.getTask({ taskId }));
             const persisted = current.roleBindings.find((candidate) => candidate.agentPackageRef === agentPackageRef);
             if (!persisted?.workerRef || !persisted.conversationLocator)
                 throw new Error("WORKER_CREATE_BINDING_NOT_PERSISTED");
+            productDiscussionHost?.releaseTaskWorker(taskId, persisted.roleRef);
         };
         const waitFor = new Set(options?.waitFor ?? []);
         const shouldWait = (agentPackageRef) => waitFor.size === 0 || waitFor.has(roleForPackage(agentPackageRef).roleRef);
@@ -1081,6 +1317,166 @@ async function constructGraph(config, executionCredential, modelCredential, reso
         getProjection: (taskId) => taskDriverPorts.getTaskDriveProjection(taskId),
         requestWake: requestTaskWake,
     });
+    productCampaignContinuationCoordinator = createProductCampaignContinuationCoordinator({
+        async getProjection(taskId) {
+            const result = task.queries.getProductContinuationProjection({ taskId });
+            if (!result.ok) {
+                const code = typeof result.error === "object" && result.error !== null
+                    ? Reflect.get(result.error, "code")
+                    : undefined;
+                if (code === "PRODUCT_CAMPAIGN_NOT_FOUND")
+                    return null;
+                throw new Error(`PRODUCT_CONTINUATION_PROJECTION_FAILED:${String(code ?? "UNKNOWN")}`);
+            }
+            return result.data;
+        },
+        async listTaskIds() {
+            return unwrap(task.queries.listTasks({})).tasks.map((summary) => summary.taskId);
+        },
+        async ensureWorkers(taskId) {
+            await ensureTaskWorkers(taskId);
+        },
+        async transferRequirement(input) {
+            unwrap(task.commands.transferProductIntentToTask({
+                ...input,
+                actorRef: "platform:campaign-continuation",
+            }));
+        },
+        async startTask(input) {
+            unwrap(task.commands.startTask({
+                taskId: input.taskId,
+                expectedTaskVersion: input.expectedTaskVersion,
+                startAuthority: {
+                    type: "CAMPAIGN_AUTHORIZATION",
+                    authorizationRef: input.authorizationRef,
+                    expectedAuthorizationVersion: input.expectedAuthorizationVersion,
+                    expectedCampaignVersion: input.expectedCampaignVersion,
+                },
+                actorRef: "platform:campaign-continuation",
+                idempotencyKey: input.idempotencyKey,
+            }));
+        },
+        getDiscussionSessionForCampaign: (campaignRef) => agent.getProductDiscussionSessionForCampaign(campaignRef),
+        updateDiscussionSessionContext: (input) => agent.updateProductDiscussionSessionContext(input),
+        kickTaskReconciliation: (taskId) => reconciliationCoordinator?.kick(taskId),
+        async onProductReviewRequired(signal) {
+            const session = agent.getProductDiscussionSession(signal.discussionRef);
+            if (session.status !== "ACTIVE" ||
+                session.roleRef !== signal.roleRef ||
+                session.generation !== signal.discussionGeneration ||
+                session.conversationRef !== signal.conversationRef ||
+                session.conversationLocator !== signal.conversationLocator ||
+                session.campaignRef !== signal.campaignRef ||
+                session.currentIntentRef !== signal.intentRef)
+                throw new Error("PRODUCT_REVIEW_DISCUSSION_STALE");
+            const reviewRequest = {
+                contract: "execution",
+                contractVersion: "1.0.0",
+                idempotencyKey: signal.reviewRef,
+                callerRef: "platform-host:campaign-continuation",
+                correlationId: signal.reviewRef,
+                roleRef: signal.roleRef,
+                capability: "product.review.deliver",
+                input: {
+                    reviewRef: signal.reviewRef,
+                    discussionRef: signal.discussionRef,
+                    discussionGeneration: signal.discussionGeneration,
+                    roleRef: signal.roleRef,
+                    conversationRef: signal.conversationRef,
+                    conversationLocator: signal.conversationLocator,
+                    campaignRef: signal.campaignRef,
+                    intentRef: signal.intentRef,
+                    terminalTaskId: signal.taskId,
+                    terminalTaskVersion: signal.terminalTaskVersion,
+                    contentFingerprint: signal.reviewRef,
+                },
+            };
+            if (!(await authorizeExecution(reviewRequest)))
+                throw new Error("PRODUCT_REVIEW_EXECUTION_IDENTITY_DENIED");
+            let executionRecord;
+            try {
+                executionRecord = object(await execution.invoke("executeCapability", reviewRequest), "product review delivery execution");
+            }
+            catch (error) {
+                await sink.write("platform-host", {
+                    timestamp: new Date().toISOString(),
+                    level: "WARN",
+                    component: "platform-host-product-campaign-continuation",
+                    event: "PRODUCT_REVIEW_REQUIRED",
+                    eventId: signal.reviewRef,
+                    correlationId: signal.reviewRef,
+                    status: "UNKNOWN",
+                    taskId: signal.taskId,
+                    roleRef: signal.roleRef,
+                    conversationLocator: signal.conversationLocator,
+                    campaignRef: signal.campaignRef,
+                    intentRef: signal.intentRef,
+                    discussionRef: signal.discussionRef,
+                    discussionGeneration: signal.discussionGeneration,
+                    terminalTaskVersion: signal.terminalTaskVersion,
+                    errorCode: "EXECUTION_OWNER_RESPONSE_UNKNOWN",
+                });
+                throw error;
+            }
+            const status = string(executionRecord.status, "execution.status");
+            const sideEffectState = string(executionRecord.sideEffectState, "execution.sideEffectState");
+            const executionRef = typeof executionRecord.executionRef === "string"
+                ? executionRecord.executionRef
+                : undefined;
+            const executionResult = typeof executionRecord.result === "object" &&
+                executionRecord.result !== null &&
+                !Array.isArray(executionRecord.result)
+                ? executionRecord.result
+                : undefined;
+            const resultData = executionResult &&
+                typeof executionResult.data === "object" &&
+                executionResult.data !== null &&
+                !Array.isArray(executionResult.data)
+                ? executionResult.data
+                : undefined;
+            const evidenceRef = executionResult?.capability === "product.review.deliver" &&
+                resultData?.reviewRef === signal.reviewRef &&
+                resultData.delivered === true &&
+                typeof resultData.evidenceRef === "string"
+                ? resultData.evidenceRef
+                : undefined;
+            const delivered = status === "SUCCEEDED" &&
+                sideEffectState === "APPLIED" &&
+                evidenceRef !== undefined;
+            const error = typeof executionRecord.error === "object" &&
+                executionRecord.error !== null &&
+                !Array.isArray(executionRecord.error)
+                ? executionRecord.error
+                : undefined;
+            const errorCode = typeof error?.code === "string" ? error.code : undefined;
+            await sink.write("platform-host", {
+                timestamp: new Date().toISOString(),
+                level: delivered ? "INFO" : "WARN",
+                component: "platform-host-product-campaign-continuation",
+                event: "PRODUCT_REVIEW_REQUIRED",
+                eventId: signal.reviewRef,
+                correlationId: signal.reviewRef,
+                status: delivered
+                    ? "DELIVERED"
+                    : status === "UNKNOWN"
+                        ? "UNKNOWN"
+                        : "FAILED",
+                taskId: signal.taskId,
+                roleRef: signal.roleRef,
+                conversationLocator: signal.conversationLocator,
+                campaignRef: signal.campaignRef,
+                intentRef: signal.intentRef,
+                discussionRef: signal.discussionRef,
+                discussionGeneration: signal.discussionGeneration,
+                terminalTaskVersion: signal.terminalTaskVersion,
+                ...(executionRef ? { executionRef } : {}),
+                ...(evidenceRef ? { evidenceRef } : {}),
+                ...(errorCode ? { errorCode } : {}),
+            });
+            if (!delivered)
+                throw new Error(`PRODUCT_REVIEW_DELIVERY_NOT_CONFIRMED:${status}:${sideEffectState}`);
+        },
+    });
     const taskApplication = observer.port("task", {
         async invoke(operation, rawInput) {
             const value = object(rawInput, "task application input");
@@ -1243,6 +1639,18 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                 void reconciliationCoordinator?.sweep();
                 return { scheduled: true };
             }
+            if (operation === "product.discussion.register")
+                throw new Error("PRODUCT_DISCUSSION_REGISTER_DIRECT_FORBIDDEN");
+            if (operation === "product.discussion.observe") {
+                if (!productDiscussionHost)
+                    throw new Error("PRODUCT_DISCUSSION_ADMISSION_UNAVAILABLE");
+                return productDiscussionHost.observe({
+                    conversationLocator: string(value.conversationLocator, "conversationLocator"),
+                    contentInstanceId: string(value.contentInstanceId, "contentInstanceId"),
+                });
+            }
+            if (operation === "product.discussion.get")
+                return agent.getProductDiscussionSession(string(value.discussionRef, "discussionRef"));
             if (operation === "browser.permission.classify") {
                 const roleRef = string(value.roleRef, "roleRef");
                 if (value.taskId !== undefined && typeof value.taskId !== "string")
@@ -1374,6 +1782,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
         },
     });
     reconciliationCoordinator.start();
+    productCampaignContinuationCoordinator.start();
     return Object.freeze({
         route,
         operationSink: sink,
@@ -1385,6 +1794,9 @@ async function constructGraph(config, executionCredential, modelCredential, reso
         taskApplication,
         approvalApplication,
         observerApplication,
+        startMonitorRotation() {
+            monitorRotationCoordinator?.start();
+        },
         async lookup(_operationId, _authenticatedRoleRef, _input) {
             throw Object.assign(new Error("ACTION_RESULT_LOOKUP_UNSUPPORTED"), { httpStatus: 409 });
         },
@@ -1414,8 +1826,17 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                 model: modelStatus,
             };
         },
-        close() {
+        async close() {
+            productCampaignContinuationCoordinator?.stop();
             reconciliationCoordinator?.stop();
+            await monitorRotationCoordinator?.stop();
+            ownerShutdown.abort();
+            await Promise.all([
+                productCampaignContinuationCoordinator?.drain(),
+                reconciliationCoordinator?.drain(),
+            ]);
+            productDiscussionHost?.clear();
+            await sink.drain();
             agent.close();
             taskStore.close();
         },
@@ -1659,9 +2080,9 @@ export function createPlatformHost(input) {
                 ? await readExecutionTransportCredential(input.config.executionTransportCredentialFile)
                 : input.executionCredential;
             log("DEPENDENCY_INITIALIZATION_STARTED", {
-                order: ["task", "agent", "execution-client", "model-client"],
+                order: ["task", "agent", "execution-client", "model-client", "monitor-control-client"],
             });
-            graph = await constructGraph(input.config, executionTransportCredential, modelTransportCredential, input.resolveOwnerConnection, input.resolveLocalToolConnection);
+            graph = await constructGraph(input.config, executionTransportCredential, modelTransportCredential, input.resolveOwnerConnection, input.resolveLocalToolConnection, input.resolveMonitorControlConnection);
             server = createServer((request, response) => {
                 const work = operationContext.run({ operationRef: incomingOperationRef(request.headers["x-proflow-operation-ref"]) }, async () => {
                     const url = new URL(request.url ?? "/", "http://platform-host.local");
@@ -1875,6 +2296,7 @@ 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 };
         }
@@ -1882,7 +2304,7 @@ export function createPlatformHost(input) {
             accepting = false;
             server?.close();
             server = undefined;
-            graph?.close();
+            await graph?.close();
             graph = undefined;
             roleManagementCredential = undefined;
             taskApplicationCredential = undefined;
@@ -1902,7 +2324,7 @@ export function createPlatformHost(input) {
         if (running)
             await new Promise((resolveStop, reject) => running.close((error) => (error ? reject(error) : resolveStop())));
         await Promise.allSettled([...active]);
-        graph?.close();
+        await graph?.close();
         graph = undefined;
         roleManagementCredential = undefined;
         taskApplicationCredential = undefined;