@tomflow/proflow-platform-host 0.1.30 → 0.1.31

package/dist/src/product-discussion-host.d.ts

@@ -0,0 +1,43 @@
+import type { ExecuteCapabilityRequest } from "@tomflow/proflow-execution-contracts";
+import { type ProductDiscussionAdmissionVerification, type ProductDiscussionSessionOwnerFact, type ProductDiscussionTaskRoleBindingFact } from "./product-discussion-admission.ts";
+export type ProductDiscussionHostTaskFact = Readonly<{
+    taskId: string;
+    status: string;
+    roleBindings: readonly ProductDiscussionTaskRoleBindingFact[];
+}>;
+export declare function createProductDiscussionHost(options: {
+    productRoleRef: string;
+    listTaskIds(): readonly string[] | Promise<readonly string[]>;
+    getTaskFact(taskId: string): ProductDiscussionHostTaskFact | Promise<ProductDiscussionHostTaskFact>;
+    registerDiscussionSession(input: {
+        discussionRef: string;
+        roleRef: string;
+        conversationRef: string;
+        conversationLocator: string;
+    }): ProductDiscussionSessionOwnerFact | Promise<ProductDiscussionSessionOwnerFact>;
+    getDiscussionSession(discussionRef: string): ProductDiscussionSessionOwnerFact | Promise<ProductDiscussionSessionOwnerFact>;
+    executeCapability(request: ExecuteCapabilityRequest): Promise<unknown>;
+}): Readonly<{
+    recoverReservations: () => Promise<void>;
+    reserveTaskWorker: (taskId: string, roleRef: string) => void;
+    releaseTaskWorker: (taskId: string, roleRef: string) => void;
+    isTaskWorkerProvisioning: (roleRef: string) => boolean;
+    observe: (input: {
+        conversationLocator: string;
+        contentInstanceId: string;
+    }) => Promise<Readonly<{
+        admitted: false;
+        reason: "NOT_CUSTOM_GPT_CONVERSATION";
+    }> | Readonly<{
+        admitted: false;
+        reason: "NOT_PRODUCT_ROLE";
+    }> | Readonly<{
+        admitted: true;
+        discussionRef: string;
+        discussionGeneration: number;
+        bootstrapRef: string;
+    }>>;
+    authorizeBootstrapExecution: (request: ExecuteCapabilityRequest) => Promise<boolean>;
+    verifyAdmission(input: ProductDiscussionAdmissionVerification): boolean;
+    clear(): void;
+}>;

package/dist/src/product-discussion-host.js

@@ -0,0 +1,167 @@
+import { assertProductDiscussionConversationPreTask, createProductDiscussionAdmissionAuthority, createProductDiscussionAdmissionCoordinator, parseProductDiscussionConversationLocator, productDiscussionRef, } from "./product-discussion-admission.js";
+const reservableTaskStatuses = new Set(["PENDING", "READY", "ACTIVE", "WAITING"]);
+function object(value, code) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new Error(code);
+    return value;
+}
+export function createProductDiscussionHost(options) {
+    const authority = createProductDiscussionAdmissionAuthority();
+    const provisioning = new Map();
+    let recovered = false;
+    const reserveTaskWorker = (taskId, roleRef) => {
+        if (roleRef !== options.productRoleRef)
+            return;
+        const current = provisioning.get(roleRef) ?? new Set();
+        current.add(taskId);
+        provisioning.set(roleRef, current);
+    };
+    const releaseTaskWorker = (taskId, roleRef) => {
+        if (roleRef !== options.productRoleRef)
+            return;
+        const current = provisioning.get(roleRef);
+        if (!current)
+            return;
+        current.delete(taskId);
+        if (current.size === 0)
+            provisioning.delete(roleRef);
+    };
+    const isTaskWorkerProvisioning = (roleRef) => roleRef === options.productRoleRef &&
+        (!recovered || (provisioning.get(roleRef)?.size ?? 0) > 0);
+    const coordinator = createProductDiscussionAdmissionCoordinator({
+        productRoleRef: options.productRoleRef,
+        authority,
+        isTaskWorkerProvisioning,
+        listTaskIds: options.listTaskIds,
+        async getTaskRoleBindings(taskId) {
+            return (await options.getTaskFact(taskId)).roleBindings;
+        },
+        registerDiscussionSession: options.registerDiscussionSession,
+        async deliverBootstrap(admission) {
+            const request = {
+                contract: "execution",
+                contractVersion: "1.0.0",
+                idempotencyKey: admission.bootstrapRef,
+                callerRef: "platform-host:product-discussion-admission",
+                correlationId: admission.bootstrapRef,
+                roleRef: admission.roleRef,
+                capability: "product.discussion.bootstrap.deliver",
+                input: {
+                    bootstrapRef: admission.bootstrapRef,
+                    discussionRef: admission.discussionRef,
+                    discussionGeneration: admission.generation,
+                    discussionAdmissionToken: admission.discussionAdmissionToken,
+                    roleRef: admission.roleRef,
+                    conversationRef: admission.conversationRef,
+                    conversationLocator: admission.conversationLocator,
+                    contentInstanceId: admission.contentInstanceId,
+                    contentFingerprint: admission.bootstrapRef,
+                },
+            };
+            const execution = object(await options.executeCapability(request), "PRODUCT_DISCUSSION_BOOTSTRAP_EXECUTION_INVALID");
+            const result = execution.result === undefined
+                ? undefined
+                : object(execution.result, "PRODUCT_DISCUSSION_BOOTSTRAP_RESULT_INVALID");
+            const data = result?.data === undefined
+                ? undefined
+                : object(result.data, "PRODUCT_DISCUSSION_BOOTSTRAP_RESULT_DATA_INVALID");
+            if (execution.status !== "SUCCEEDED" ||
+                execution.sideEffectState !== "APPLIED" ||
+                result?.capability !== "product.discussion.bootstrap.deliver" ||
+                data?.bootstrapRef !== admission.bootstrapRef ||
+                data?.delivered !== true ||
+                typeof data.evidenceRef !== "string")
+                throw new Error(`PRODUCT_DISCUSSION_BOOTSTRAP_NOT_CONFIRMED:${String(execution.status)}:${String(execution.sideEffectState)}`);
+        },
+    });
+    const recoverReservations = async () => {
+        if (recovered)
+            return;
+        const taskIds = await options.listTaskIds();
+        for (const taskId of taskIds) {
+            const task = await options.getTaskFact(taskId);
+            if (!reservableTaskStatuses.has(task.status))
+                continue;
+            for (const binding of task.roleBindings)
+                if (binding.roleRef === options.productRoleRef &&
+                    (!binding.workerRef || !binding.conversationLocator))
+                    reserveTaskWorker(task.taskId, binding.roleRef);
+        }
+        recovered = true;
+    };
+    const authorizeBootstrapExecution = async (request) => {
+        if (request.capability !== "product.discussion.bootstrap.deliver")
+            return false;
+        try {
+            if (!recovered)
+                return false;
+            if (request.callerRef !== "platform-host:product-discussion-admission")
+                return false;
+            if (request.taskId !== undefined ||
+                request.nodeId !== undefined ||
+                request.runNo !== undefined ||
+                request.workerRef !== undefined ||
+                request.projectRoot !== undefined)
+                return false;
+            const input = request.input;
+            if (request.roleRef !== options.productRoleRef ||
+                input.roleRef !== options.productRoleRef ||
+                isTaskWorkerProvisioning(input.roleRef) ||
+                input.contentFingerprint !== input.bootstrapRef)
+                return false;
+            const identity = parseProductDiscussionConversationLocator(input.conversationLocator);
+            if (!identity ||
+                identity.roleRef !== input.roleRef ||
+                identity.conversationRef !== input.conversationRef ||
+                productDiscussionRef(identity) !== input.discussionRef)
+                return false;
+            await assertProductDiscussionConversationPreTask({
+                conversationLocator: input.conversationLocator,
+                listTaskIds: options.listTaskIds,
+                async getTaskRoleBindings(taskId) {
+                    return (await options.getTaskFact(taskId)).roleBindings;
+                },
+            });
+            const session = await options.getDiscussionSession(input.discussionRef);
+            if (session.status !== "ACTIVE" ||
+                session.discussionRef !== input.discussionRef ||
+                session.roleRef !== input.roleRef ||
+                session.conversationRef !== input.conversationRef ||
+                session.conversationLocator !== input.conversationLocator ||
+                session.generation !== input.discussionGeneration)
+                return false;
+            const current = authority.get(input.discussionRef);
+            if (!current ||
+                current.bootstrapRef !== input.bootstrapRef ||
+                current.contentInstanceId !== input.contentInstanceId)
+                return false;
+            return authority.verify({
+                discussionRef: input.discussionRef,
+                roleRef: input.roleRef,
+                conversationRef: input.conversationRef,
+                conversationLocator: input.conversationLocator,
+                generation: input.discussionGeneration,
+                discussionAdmissionToken: input.discussionAdmissionToken,
+            });
+        }
+        catch {
+            return false;
+        }
+    };
+    return Object.freeze({
+        recoverReservations,
+        reserveTaskWorker,
+        releaseTaskWorker,
+        isTaskWorkerProvisioning,
+        observe: coordinator.observe,
+        authorizeBootstrapExecution,
+        verifyAdmission(input) {
+            return recovered && !isTaskWorkerProvisioning(input.roleRef) && authority.verify(input);
+        },
+        clear() {
+            authority.clear();
+            provisioning.clear();
+            recovered = false;
+        },
+    });
+}

package/dist/src/reconciliation-coordinator.d.ts

@@ -33,5 +33,6 @@ export declare function createReconciliationCoordinator(options: ReconciliationC
     kick(taskId: string, signal?: TaskResumeSignal): void;
     reconcile: (taskId: string, signal?: TaskResumeSignal) => Promise<void>;
     sweep: () => Promise<void>;
+    drain(): Promise<void>;
     stop(): void;
 }>;

package/dist/src/reconciliation-coordinator.js

@@ -197,8 +197,7 @@ export function createReconciliationCoordinator(options) {
             }
         })().finally(() => {
             taskInFlight.delete(taskId);
-            if (!stopped &&
-                (pendingSignals.has(taskId) || failures.has(taskId)))
+            if (!stopped && (pendingSignals.has(taskId) || failures.has(taskId)))
                 schedulePendingRetry(taskId);
             else
                 admittedTasks.delete(taskId);
@@ -318,6 +317,12 @@ export function createReconciliationCoordinator(options) {
         },
         reconcile,
         sweep,
+        async drain() {
+            await Promise.allSettled([
+                ...(sweepInFlight ? [sweepInFlight] : []),
+                ...taskInFlight.values(),
+            ]);
+        },
         stop() {
             if (stopped)
                 return;

package/dist/src/role-operations.js

@@ -42,6 +42,14 @@ export const roleOperations = {
         "getTask",
         "putTaskDocument",
         "getTaskDocument",
+        "getProductCampaign",
+        "getProductDiscussionContext",
+        "getProductDocument",
+        "putProductDocument",
+        "getCampaignAuthorization",
+        "submitProductTaskIntent",
+        "recordProductGapReview",
+        "recordProductGoalSatisfied",
         "askPeer",
         "replyPeer",
         ...directToolActionIds,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomflow/proflow-platform-host",
-  "version": "0.1.30",
+  "version": "0.1.31",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -24,19 +24,19 @@
   ],
   "dependencies": {
     "zod": "4.1.12",
-    "@tomflow/proflow-execution-browser-extension": "^0.1.62",
-    "@tomflow/proflow-task-migration-runner": "^0.1.11",
-    "@tomflow/proflow-task-orchestration": "^0.1.11",
-    "@tomflow/proflow-task-store-sqlite": "^0.1.12",
     "@tomflow/proflow-agent-runtime": "^0.1.17",
     "@tomflow/proflow-module-contract": "^0.1.13",
-    "@tomflow/proflow-execution-contracts": "^0.1.11"
+    "@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"
   },
   "devDependencies": {
-    "@tomflow/proflow-deployment-conformance": "^0.1.13",
     "@tomflow/proflow-execution-runtime": "^0.1.19",
-    "@tomflow/proflow-model-runtime": "^0.1.25",
-    "@tomflow/proflow-agent-gateway": "^0.1.18"
+    "@tomflow/proflow-deployment-conformance": "^0.1.13",
+    "@tomflow/proflow-agent-gateway": "^0.1.19",
+    "@tomflow/proflow-model-runtime": "^0.1.26"
   },
   "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.30",
+	"moduleVersion": "0.1.31",
 	"kind": "service",
 	"templateVersion": "1.0.0",
 	"platformCompatibility": ">=1.0.0 <2.0.0",