@tomflow/proflow-platform-host 0.1.23 → 0.1.25

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @tomflow/proflow-platform-host
 
+## 0.1.25
+
+### Patch Changes
+
+- Harden task-agnostic Browser Permission trust resolution so ambiguous or unreadable durable Worker bindings fail closed while preserving exact Task-scoped validation.
+
+## 0.1.24
+
+### Patch Changes
+
+- Retry ordinary READY-node reconciliation with bounded task-local backoff when worker wake delivery fails, so Dev completion can reliably hand off to Test without relying only on the global sweep.
+
 ## 0.1.23
 
 ### 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.23";
+            moduleVersion: "0.1.25";
             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.23";
+            readonly moduleVersion: "0.1.25";
         };
         observedEffects: string[];
     }>;
@@ -34,7 +34,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.23";
+            moduleVersion: "0.1.25";
             data: {
                 setupStatus: "READY";
                 runtimeStatus: "RUNNING" | "STOPPED";
@@ -48,7 +48,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.23";
+            moduleVersion: "0.1.25";
             data: {
                 endpoint: string;
                 stateRoot: string;
@@ -66,7 +66,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.23";
+            moduleVersion: "0.1.25";
             data: {
                 docs: string;
             };
@@ -79,7 +79,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.23";
+            moduleVersion: "0.1.25";
             data: {
                 host: string;
                 port: number;
@@ -90,7 +90,7 @@ export declare const behaviorAdapter: {
         result: {
             contract: "deployment.result.v1";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.23";
+            moduleVersion: "0.1.25";
             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.23";
+            readonly moduleVersion: "0.1.25";
         };
         observedEffects: string[];
     } | {
@@ -116,11 +116,11 @@ export declare const behaviorAdapter: {
             readonly ok: true;
             readonly status: "SUCCEEDED";
             readonly moduleRef: "platform-host";
-            readonly moduleVersion: "0.1.23";
+            readonly moduleVersion: "0.1.25";
         } | {
             contract: "deployment.result.v1";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.23";
+            moduleVersion: "0.1.25";
             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.23";
+    readonly moduleVersion: "0.1.25";
     readonly kind: "service";
     readonly templateVersion: "1.0.0";
     readonly platformCompatibility: ">=1.0.0 <2.0.0";
@@ -27,7 +27,6 @@ export declare const descriptor: {
     }];
     readonly requirements: readonly [{
         readonly kind: "runtime";
-        readonly runtime: "node";
         readonly versionRange: ">=24.19.0";
     }];
     readonly configSlots: readonly [];

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.23",
+    moduleVersion: "0.1.25",
     kind: "service",
     templateVersion: "1.0.0",
     platformCompatibility: ">=1.0.0 <2.0.0",
@@ -34,7 +34,6 @@ export const descriptor = {
     requirements: [
         {
             kind: "runtime",
-            runtime: "node",
             versionRange: ">=24.19.0",
         },
     ],

package/dist/src/browser-permission-context.d.ts

@@ -0,0 +1,15 @@
+export type BrowserPermissionTaskBinding = {
+    agentPackageRef: string;
+    roleRef: string;
+    workerRef: string | null;
+    conversationLocator: string | null;
+};
+export declare function resolveBrowserPermissionTaskBinding(input: {
+    taskId?: string;
+    agentPackageRef: string;
+    roleRef: string;
+    workerRef: string | null;
+    conversationLocator: string;
+    listTaskIds(): readonly string[];
+    getRoleBindings(taskId: string): readonly BrowserPermissionTaskBinding[] | null;
+}): BrowserPermissionTaskBinding | null;

package/dist/src/browser-permission-context.js

@@ -0,0 +1,31 @@
+export function resolveBrowserPermissionTaskBinding(input) {
+    const matchingRole = (bindings) => unique(bindings?.filter((binding) => binding.roleRef === input.roleRef &&
+        binding.agentPackageRef === input.agentPackageRef) ?? []);
+    if (input.taskId !== undefined)
+        return matchingRole(input.getRoleBindings(input.taskId));
+    if (input.workerRef === null)
+        return null;
+    let match = null;
+    for (const taskId of input.listTaskIds()) {
+        const bindings = input.getRoleBindings(taskId);
+        // An incomplete scan cannot establish an unambiguous durable identity.
+        if (bindings === null)
+            return null;
+        for (const binding of bindings) {
+            if (binding.conversationLocator !== input.conversationLocator &&
+                !(binding.roleRef === input.roleRef && binding.workerRef === input.workerRef))
+                continue;
+            if (match !== null ||
+                binding.agentPackageRef !== input.agentPackageRef ||
+                binding.roleRef !== input.roleRef ||
+                binding.workerRef !== input.workerRef ||
+                binding.conversationLocator !== input.conversationLocator)
+                return null;
+            match = binding;
+        }
+    }
+    return match;
+}
+function unique(bindings) {
+    return bindings.length === 1 ? bindings[0] ?? null : null;
+}

package/dist/src/index.js

@@ -10,12 +10,11 @@ import { createTaskServices, publicOperationNames, } from "@tomflow/proflow-task
 import { SqliteTaskStore } from "@tomflow/proflow-task-store-sqlite";
 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 { 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]"]);
-// Business owner calls are Promise-driven. This is only a last-resort transport
-// watchdog for a hung local call, not a normal workflow deadline.
 const OWNER_INVOKE_WATCHDOG_MS = 120_000;
 const systemObserverReasonResultSchema = z
     .object({
@@ -343,9 +342,7 @@ function createOwnerHttpClient(owner, baseUrl, credential, resolveConnection) {
                         : {}),
                 },
                 ...(method === "POST"
-                    ? {
-                        body: JSON.stringify(requestBody),
-                    }
+                    ? { body: JSON.stringify(requestBody) }
                     : {}),
                 signal: AbortSignal.timeout(OWNER_INVOKE_WATCHDOG_MS),
             }));
@@ -372,9 +369,6 @@ function unwrap(result) {
         throw new Error(`OWNER_CONTRACT_FAILED:${JSON.stringify(result.error)}`);
     return result.data;
 }
-// Bounded read of the Deployment owner's explicit System Observer projection.
-// Platform Host never reads Deployment's internal state.json or derives health;
-// it consumes only the bounded summary emitted by Deployment status/verify/doctor.
 async function readDeploymentOwnerSummary(stateRoot) {
     try {
         const raw = await readFile(join(stateRoot, "deployment", "observer-summary.json"), "utf8");
@@ -396,9 +390,8 @@ async function readDeploymentOwnerSummary(stateRoot) {
             Number.isNaN(Date.parse(record.observedAt)) ||
             Number.isNaN(Date.parse(record.freshUntil)) ||
             record.selectedModuleCount !== record.totalModuleCount ||
-            Date.parse(record.freshUntil) <= Date.now()) {
+            Date.parse(record.freshUntil) <= Date.now())
             return undefined;
-        }
         return {
             state: record.state,
             source: record.source,
@@ -416,17 +409,11 @@ async function readDeploymentOwnerSummary(stateRoot) {
 }
 async function constructGraph(config, executionCredential, modelCredential, resolveConnection, resolveLocalToolConnection) {
     const databasePath = join(config.stateRoot, "state", "task.sqlite");
-    const migration = applyMigrations({
-        databasePath,
-        migrations: taskMigrations,
-    });
+    const migration = applyMigrations({ databasePath, migrations: taskMigrations });
     if (!migration.ok)
         throw new Error(`TASK_MIGRATION_FAILED:${migration.error?.message}`);
     const taskStore = new SqliteTaskStore({ databasePath });
-    const task = createTaskServices({
-        store: taskStore,
-        workspaceRoot: config.workspaceRoot,
-    });
+    const task = createTaskServices({ store: taskStore, workspaceRoot: config.workspaceRoot });
     const taskFacts = (taskId) => {
         const value = unwrap(task.queries.getTask({ taskId }));
         return {
@@ -509,9 +496,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             };
         }
         if (view === "collaboration") {
-            const pending = await agent.listPendingCollaborationMessages({
-                limit: 100,
-            });
+            const pending = await agent.listPendingCollaborationMessages({ limit: 100 });
             return {
                 summary: `pendingMessages=${pending.length}`,
                 health: pending.length < 100 ? "HEALTHY" : "DEGRADED",
@@ -521,22 +506,16 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             const status = object(await model.invoke("getRuntimeStatus", {}), "model status");
             return {
                 summary: JSON.stringify(status).slice(0, 2_000),
-                health: status.runtime === "READY"
-                    ? "HEALTHY"
-                    : "DEGRADED",
+                health: status.runtime === "READY" ? "HEALTHY" : "DEGRADED",
             };
         }
         if (view === "execution") {
             const readiness = await execution.readiness();
             const signalResult = object(await execution.invoke("listExecutionObserverSignals", { limit: 50 }), "execution observer signals");
-            const signals = Array.isArray(signalResult.signals)
-                ? signalResult.signals
-                : [];
+            const signals = Array.isArray(signalResult.signals) ? signalResult.signals : [];
             return {
                 summary: `execution owner readiness=${readiness.status}; liveness=${readiness.liveness}; pendingObserverSignals=${signals.length}`,
-                health: readiness.status === "READY"
-                    ? "HEALTHY"
-                    : "DEGRADED",
+                health: readiness.status === "READY" ? "HEALTHY" : "DEGRADED",
             };
         }
         if (view === "carrier") {
@@ -549,7 +528,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
         }
         if (view === "deployment") {
             const deployment = await readDeploymentOwnerSummary(config.stateRoot);
-            if (deployment === undefined) {
+            if (deployment === undefined)
                 return {
                     summary: "deployment owner summary unavailable",
                     health: "UNKNOWN",
@@ -558,15 +537,10 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                         "Deployment current state is not materialized; no substitute owner readiness is inferred",
                     ],
                 };
-            }
             return {
                 summary: `deploymentOwnerState=${deployment.state}; source=${deployment.source}; selectedModules=${deployment.selectedModuleCount}; observedModules=${deployment.observedModuleCount}; blockingModules=${deployment.blockingModuleCount}; observedAt=${deployment.observedAt}`,
-                health: deployment.state === "READY"
-                    ? "HEALTHY"
-                    : "DEGRADED",
-                findings: deployment.state === "READY"
-                    ? []
-                    : [`Deployment owner reports ${deployment.state}`],
+                health: deployment.state === "READY" ? "HEALTHY" : "DEGRADED",
+                findings: deployment.state === "READY" ? [] : [`Deployment owner reports ${deployment.state}`],
             };
         }
         if (view === "artifact") {
@@ -634,31 +608,18 @@ async function constructGraph(config, executionCredential, modelCredential, reso
         "reopenNode",
         "putTaskDocument",
     ]);
-    // Unified external Task-scoped Action admission. TaskRoleBinding is a Task
-    // owner fact, so participant + canonical Worker identity are derived from the
-    // Task owner facts, never from an untrusted body roleRef/workerRef. Reads only
-    // gate participation (terminal Tasks stay readable); mutations and Execution
-    // additionally run the full Agent Worker validation (which rejects terminal
-    // Tasks) before acting.
     const admitTaskParticipant = async (taskId, authenticatedRoleRef, suppliedWorkerRef) => {
         const binding = taskFacts(taskId).roleBindings.find((candidate) => candidate.roleRef === authenticatedRoleRef);
         if (!binding?.workerRef)
-            throw Object.assign(new Error("TASK_ROLE_BINDING_REQUIRED"), {
-                httpStatus: 403,
-            });
-        if (suppliedWorkerRef !== undefined &&
-            suppliedWorkerRef !== binding.workerRef)
-            throw Object.assign(new Error("TASK_WORKER_BINDING_MISMATCH"), {
-                httpStatus: 403,
-            });
+            throw Object.assign(new Error("TASK_ROLE_BINDING_REQUIRED"), { httpStatus: 403 });
+        if (suppliedWorkerRef !== undefined && suppliedWorkerRef !== binding.workerRef)
+            throw Object.assign(new Error("TASK_WORKER_BINDING_MISMATCH"), { httpStatus: 403 });
         return binding.workerRef;
     };
     const route = async (operationId, authenticatedRoleRef, rawInput, context) => {
         const role = agent.getRegisteredRole(authenticatedRoleRef);
         if (!roleOperations[role.agentPackageRef]?.has(operationId))
-            throw Object.assign(new Error("ROLE_OPERATION_DENIED"), {
-                httpStatus: 403,
-            });
+            throw Object.assign(new Error("ROLE_OPERATION_DENIED"), { httpStatus: 403 });
         const input = object(rawInput, "action input");
         if (operationId === "askPeer")
             return agent.askPeer({ ...input, authenticatedRoleRef });
@@ -668,27 +629,18 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             const tool = operationId;
             const keys = Object.keys(input).sort();
             if (keys.length !== 2 || keys[0] !== "input" || keys[1] !== "operation")
-                throw Object.assign(new Error("DIRECT_TOOL_INPUT_INVALID"), {
-                    httpStatus: 400,
-                });
+                throw Object.assign(new Error("DIRECT_TOOL_INPUT_INVALID"), { httpStatus: 400 });
             const toolOperation = string(input.operation, "operation");
             const toolInput = object(input.input, "input");
             assertNoDirectToolPlatformIdentity(toolInput);
             if (!roleAllowsDirectToolOperation(role.agentPackageRef, operationId, toolOperation, toolInput))
-                throw Object.assign(new Error("ROLE_TOOL_OPERATION_DENIED"), {
-                    httpStatus: 403,
-                });
+                throw Object.assign(new Error("ROLE_TOOL_OPERATION_DENIED"), { httpStatus: 403 });
             const deadlineAt = context?.deadlineAt;
-            if (typeof deadlineAt !== "string" ||
-                Number.isNaN(Date.parse(deadlineAt)))
-                throw Object.assign(new Error("DIRECT_TOOL_DEADLINE_REQUIRED"), {
-                    httpStatus: 400,
-                });
+            if (typeof deadlineAt !== "string" || Number.isNaN(Date.parse(deadlineAt)))
+                throw Object.assign(new Error("DIRECT_TOOL_DEADLINE_REQUIRED"), { httpStatus: 400 });
             const connection = await resolveLocalToolConnection?.();
             if (!connection)
-                throw Object.assign(new Error("LOCAL_TOOL_BRIDGE_UNAVAILABLE"), {
-                    httpStatus: 503,
-                });
+                throw Object.assign(new Error("LOCAL_TOOL_BRIDGE_UNAVAILABLE"), { httpStatus: 503 });
             try {
                 return await createLocalToolBridgeHostClient({
                     endpoint: connection.endpoint,
@@ -712,8 +664,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                         ? 409
                         : code === "LOCAL_TOOL_SCOPE_DENIED"
                             ? 403
-                            : code === "LOCAL_TOOL_OFFLINE" ||
-                                code === "LOCAL_TOOL_PROVIDER_UNAVAILABLE"
+                            : code === "LOCAL_TOOL_OFFLINE" || code === "LOCAL_TOOL_PROVIDER_UNAVAILABLE"
                                 ? 503
                                 : code === "LOCAL_TOOL_COMMAND_FAILED"
                                     ? 500
@@ -739,7 +690,9 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             let canonicalTaskInput = input;
             if (context?.fileMaterializationInputs !== undefined) {
                 if (operationId !== "putTaskDocument")
-                    throw Object.assign(new Error("FILE_MATERIALIZATION_UNSUPPORTED_OPERATION"), { httpStatus: 400 });
+                    throw Object.assign(new Error("FILE_MATERIALIZATION_UNSUPPORTED_OPERATION"), {
+                        httpStatus: 400,
+                    });
                 const taskMutationIdempotencyKey = string(input.idempotencyKey, "idempotencyKey");
                 const result = object(await execution.invoke("materializeExternalFiles", {
                     contract: "execution.external-file-materialization",
@@ -747,19 +700,13 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                     callerRef: authenticatedRoleRef,
                     idempotencyKey: `${taskMutationIdempotencyKey}:carrier-file-materialization`,
                     correlationId: taskMutationIdempotencyKey,
-                    ...(typeof input.taskId === "string"
-                        ? { taskId: input.taskId }
-                        : {}),
+                    ...(typeof input.taskId === "string" ? { taskId: input.taskId } : {}),
                     roleRef: authenticatedRoleRef,
-                    ...(canonicalWorkerRef !== undefined
-                        ? { workerRef: canonicalWorkerRef }
-                        : {}),
+                    ...(canonicalWorkerRef !== undefined ? { workerRef: canonicalWorkerRef } : {}),
                     files: context.fileMaterializationInputs,
                 }), "carrier file materialization result");
                 if (!Array.isArray(result.files) || result.files.length !== 1)
-                    throw Object.assign(new Error("FILE_MATERIALIZATION_COUNT_INVALID"), {
-                        httpStatus: 400,
-                    });
+                    throw Object.assign(new Error("FILE_MATERIALIZATION_COUNT_INVALID"), { httpStatus: 400 });
                 const file = object(result.files[0], "materialized carrier file");
                 const content = string(file.content, "materialized carrier file content");
                 canonicalTaskInput = { ...input, content };
@@ -767,8 +714,7 @@ 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);
             if (operationId === "getTaskDocument")
                 return fileBridgeOutputForTaskResult(taskResult);
@@ -781,10 +727,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             async getWorkerBinding(taskId, roleRef) {
                 const binding = taskFacts(taskId).roleBindings.find((candidate) => candidate.roleRef === roleRef);
                 return binding?.workerRef
-                    ? {
-                        workerRef: binding.workerRef,
-                        conversationLocator: binding.conversationLocator,
-                    }
+                    ? { workerRef: binding.workerRef, conversationLocator: binding.conversationLocator }
                     : null;
             },
             async bindWorker(binding) {
@@ -811,28 +754,21 @@ async function constructGraph(config, executionCredential, modelCredential, reso
         }),
         agent: Object.freeze({
             async listPendingMessages(limit) {
-                const messages = await agent.listPendingCollaborationMessages({
-                    limit,
-                });
+                const messages = await agent.listPendingCollaborationMessages({ limit });
                 return messages
                     .filter((message) => message.lastDeliveryErrorCode !== "UNKNOWN")
                     .map((message) => ({ ...message, status: "PENDING" }));
             },
             async getPendingMessage(messageRef) {
-                const message = agent.getCollaborationMessage({
-                    messageId: messageRef,
-                });
+                const message = agent.getCollaborationMessage({ messageId: messageRef });
                 if (message.status !== "PENDING")
                     throw new Error("COLLABORATION_MESSAGE_NOT_PENDING");
-                // A terminal Task must never re-enter the physical Browser delivery path.
                 if (taskIsTerminal(taskFacts(message.taskId).status))
                     throw new Error("TASK_TERMINAL");
                 return { ...message, status: "PENDING" };
             },
             async reportDeliveryOutcome(input) {
-                const message = agent.getCollaborationMessage({
-                    messageId: input.messageRef,
-                });
+                const message = agent.getCollaborationMessage({ messageId: input.messageRef });
                 if (message.status === "DELIVERED")
                     return;
                 await agent.reportCollaborationDelivery({
@@ -859,16 +795,12 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                 request.callerRef === "extension:collaboration-carrier";
             if (!internalBrowserCaller)
                 agent.getRegisteredRole(request.callerRef);
-            if (request.roleRef &&
-                !internalBrowserCaller &&
-                request.roleRef !== request.callerRef)
+            if (request.roleRef && !internalBrowserCaller && request.roleRef !== request.callerRef)
                 return false;
-            if (request.projectRoot &&
-                resolve(request.projectRoot) !== config.workspaceRoot)
+            if (request.projectRoot && resolve(request.projectRoot) !== config.workspaceRoot)
                 return false;
             const nodeScoped = request.nodeId !== undefined || request.runNo !== undefined;
-            if (nodeScoped &&
-                (request.nodeId === undefined || request.runNo === undefined))
+            if (nodeScoped && (request.nodeId === undefined || request.runNo === undefined))
                 return false;
             if (nodeScoped && !request.taskId)
                 return false;
@@ -880,8 +812,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                 return false;
             if (request.taskId) {
                 const taskFact = taskFacts(request.taskId);
-                if (request.capability === "collaboration.deliver" &&
-                    taskIsTerminal(taskFact.status))
+                if (request.capability === "collaboration.deliver" && taskIsTerminal(taskFact.status))
                     return false;
                 if (request.workerRef && !internalBrowserCaller)
                     await agent.validateWorker({
@@ -890,10 +821,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                         workerRef: request.workerRef,
                     });
                 if (request.nodeId) {
-                    const nodeContext = unwrap(task.queries.getNodeContext({
-                        taskId: request.taskId,
-                        nodeId: request.nodeId,
-                    }));
+                    const nodeContext = unwrap(task.queries.getNodeContext({ taskId: request.taskId, nodeId: request.nodeId }));
                     if (taskFact.status !== "ACTIVE")
                         return false;
                     if (taskFact.currentNodeId !== nodeContext.node.nodeId)
@@ -902,12 +830,10 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                         return false;
                     if (!browserCapability && nodeContext.node.status !== "IN_PROGRESS")
                         return false;
-                    const nodeBinding = taskFact.roleBindings.find((candidate) => candidate.agentPackageRef ===
-                        nodeContext.node.requiredAgentPackageRef);
+                    const nodeBinding = taskFact.roleBindings.find((candidate) => candidate.agentPackageRef === nodeContext.node.requiredAgentPackageRef);
                     if (!nodeBinding?.workerRef)
                         return false;
-                    const scopedRoleRef = request.roleRef ??
-                        (internalBrowserCaller ? undefined : request.callerRef);
+                    const scopedRoleRef = request.roleRef ?? (internalBrowserCaller ? undefined : request.callerRef);
                     if (scopedRoleRef !== nodeBinding.roleRef)
                         return false;
                     if (request.workerRef !== nodeBinding.workerRef)
@@ -999,19 +925,14 @@ async function constructGraph(config, executionCredential, modelCredential, reso
         },
     });
     const roleForPackage = (agentPackageRef) => {
-        const role = agent
-            .listRegisteredRoles()
-            .find((candidate) => candidate.agentPackageRef === agentPackageRef);
+        const role = agent.listRegisteredRoles().find((candidate) => candidate.agentPackageRef === agentPackageRef);
         if (!role)
             throw new Error("ROLE_NOT_FOUND");
         return role;
     };
     const browserPermissionRole = (roleRef) => {
-        const role = agent
-            .listRegisteredRoles()
-            .find((candidate) => candidate.roleRef === roleRef);
-        if (!role ||
-            !rolePackageRefs.includes(role.agentPackageRef))
+        const role = agent.listRegisteredRoles().find((candidate) => candidate.roleRef === roleRef);
+        if (!role || !rolePackageRefs.includes(role.agentPackageRef))
             return null;
         return { ...role, agentPackageRef: role.agentPackageRef };
     };
@@ -1039,9 +960,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                 value.moduleRef !== "agent-gateway")
                 return null;
             const facts = object(value.facts, "agent gateway facts");
-            return typeof facts.publicBaseUrl === "string"
-                ? facts.publicBaseUrl
-                : null;
+            return typeof facts.publicBaseUrl === "string" ? facts.publicBaseUrl : null;
         }
         catch {
             return null;
@@ -1068,17 +987,12 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                     issues.push(`ROLE_CARRIER_URL_MISMATCH:${role.roleRef}`);
                 const expectedPackageVersion = Reflect.get(value, "expectedPackageVersion");
                 if (expectedPackageVersion !== undefined &&
-                    (typeof expectedPackageVersion !== "string" ||
-                        expectedPackageVersion.length === 0))
+                    (typeof expectedPackageVersion !== "string" || expectedPackageVersion.length === 0))
                     throw new TypeError("expectedPackageVersion must be a non-empty string");
                 if (typeof expectedPackageVersion === "string" &&
                     role.registeredPackageVersion !== expectedPackageVersion)
                     issues.push(`ROLE_PACKAGE_VERSION_DRIFT:${role.roleRef}:${role.registeredPackageVersion}:${expectedPackageVersion}`);
-                return {
-                    status: issues.length === 0 ? "PASS" : "FAIL",
-                    role,
-                    issues,
-                };
+                return { status: issues.length === 0 ? "PASS" : "FAIL", role, issues };
             }
             if (operation === "role.delete") {
                 await agent.deleteRole(role.roleRef);
@@ -1122,27 +1036,16 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             if (!persisted?.workerRef || !persisted.conversationLocator)
                 throw new Error("WORKER_CREATE_BINDING_NOT_PERSISTED");
         };
-        // Dispatch all three fixed Workers concurrently. When `waitFor` names a
-        // subset of roleRefs (the J1 Product path), only those results gate the
-        // return; the remaining Worker creation is a durable, idempotent Execution
-        // effect whose completion backend reconciliation recovers from the
-        // durable Task binding facts — never a bare in-memory promise.
         const waitFor = new Set(options?.waitFor ?? []);
-        const shouldWait = (agentPackageRef) => waitFor.size === 0 ||
-            waitFor.has(roleForPackage(agentPackageRef).roleRef);
+        const shouldWait = (agentPackageRef) => waitFor.size === 0 || waitFor.has(roleForPackage(agentPackageRef).roleRef);
         const pending = rolePackageRefs.map((agentPackageRef) => ({
             agentPackageRef,
             promise: provision(agentPackageRef),
         }));
         const awaited = pending.filter((entry) => shouldWait(entry.agentPackageRef));
         const deferred = pending.filter((entry) => !shouldWait(entry.agentPackageRef));
-        for (const entry of deferred) {
-            entry.promise.catch(() => {
-                // Deferred Worker creation failure is recoverable: the durable
-                // binding stays unset, so a later backend reconciliation pass re-provisions
-                // only the missing role.
-            });
-        }
+        for (const entry of deferred)
+            entry.promise.catch(() => { });
         const results = await Promise.allSettled(awaited.map((entry) => entry.promise));
         const failure = results.find((result) => result.status === "rejected");
         if (failure)
@@ -1173,22 +1076,14 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                 fingerprint: `wake:${input.taskId}:${input.nodeId}:${input.runNo}:${input.trigger}:${underlyingRef}`,
             },
         }), "task reconciliation wake execution");
-        if (wakeExecution.status !== "SUCCEEDED" ||
-            wakeExecution.sideEffectState !== "APPLIED")
+        if (wakeExecution.status !== "SUCCEEDED" || wakeExecution.sideEffectState !== "APPLIED")
             throw new Error(`TASK_WAKE_NOT_CONFIRMED:${String(wakeExecution.status)}:${String(wakeExecution.sideEffectState)}`);
         return wakeExecution;
     };
     reconciliationCoordinator = createReconciliationCoordinator({
         async listTaskPage(input) {
             return taskStore.listReconciliationTaskIds({
-                statuses: [
-                    "PENDING",
-                    "READY",
-                    "ACTIVE",
-                    "WAITING",
-                    "FAILED",
-                    "PAUSED",
-                ],
+                statuses: ["PENDING", "READY", "ACTIVE", "WAITING", "FAILED", "PAUSED"],
                 ...input,
             });
         },
@@ -1200,9 +1095,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             return Array.isArray(batch.signals) ? batch.signals : [];
         },
         async acknowledgeExecutionSignal(signalRef) {
-            await execution.invoke("acknowledgeExecutionObserverSignal", {
-                signalRef,
-            });
+            await execution.invoke("acknowledgeExecutionObserverSignal", { signalRef });
         },
         async ensureWorkers(taskId) {
             await ensureTaskWorkers(taskId);
@@ -1216,9 +1109,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             if (operation === "task.create") {
                 const idempotencyKey = string(value.idempotencyKey, "idempotencyKey");
                 const created = unwrap(task.commands.createTask({
-                    ...(typeof value.taskId === "string"
-                        ? { taskId: value.taskId }
-                        : {}),
+                    ...(typeof value.taskId === "string" ? { taskId: value.taskId } : {}),
                     title: string(value.title, "title"),
                     objective: string(value.objective, "objective"),
                     plan: object(value.plan, "plan"),
@@ -1237,9 +1128,6 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                     actorRef: "extension:human",
                     idempotencyKey,
                 }));
-                // J1: return once the Product Worker is durably bound; Dev/Test
-                // continue as recoverable durable effects without blocking Product
-                // requirement discussion.
                 const provisioned = await ensureTaskWorkers(created.taskId, {
                     waitFor: [roleForPackage("@tomflow/proflow-agent-product").roleRef],
                 });
@@ -1248,9 +1136,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             }
             if (operation === "task.list")
                 return unwrap(task.queries.listTasks({
-                    ...(Array.isArray(value.statuses)
-                        ? { statuses: value.statuses }
-                        : {}),
+                    ...(Array.isArray(value.statuses) ? { statuses: value.statuses } : {}),
                 }));
             if (operation === "task.get")
                 return unwrap(task.queries.getTask({ taskId: string(value.taskId, "taskId") }));
@@ -1268,9 +1154,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             if (operation === "message.acknowledge")
                 return unwrap(task.commands.acknowledgeMessage({
                     messageId: string(value.messageId, "messageId"),
-                    ...(typeof value.resolution === "string"
-                        ? { resolution: value.resolution }
-                        : {}),
+                    ...(typeof value.resolution === "string" ? { resolution: value.resolution } : {}),
                     actorRef: "extension:human",
                     idempotencyKey: string(value.idempotencyKey, "idempotencyKey"),
                 }));
@@ -1383,26 +1267,31 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             }
             if (operation === "browser.permission.classify") {
                 const roleRef = string(value.roleRef, "roleRef");
-                const taskId = string(value.taskId, "taskId");
+                if (value.taskId !== undefined && typeof value.taskId !== "string")
+                    return { decision: "HUMAN_REQUIRED", reason: "CONTEXT_MISMATCH" };
+                const taskId = typeof value.taskId === "string" ? value.taskId : undefined;
                 const operationId = string(value.operationId, "operationId");
                 const conversationLocator = string(value.conversationLocator, "conversationLocator");
                 const workerRef = typeof value.workerRef === "string" ? value.workerRef : null;
                 const role = browserPermissionRole(roleRef);
                 if (!role)
-                    return {
-                        decision: "HUMAN_REQUIRED",
-                        reason: "ROLE_VALIDATION_MISMATCH",
-                    };
-                let taskBinding = null;
-                try {
-                    const current = unwrap(task.queries.getTask({ taskId }));
-                    taskBinding =
-                        current.roleBindings.find((candidate) => candidate.roleRef === roleRef &&
-                            candidate.agentPackageRef === role.agentPackageRef) ?? null;
-                }
-                catch {
-                    taskBinding = null;
-                }
+                    return { decision: "HUMAN_REQUIRED", reason: "ROLE_VALIDATION_MISMATCH" };
+                const taskBinding = resolveBrowserPermissionTaskBinding({
+                    ...(taskId === undefined ? {} : { taskId }),
+                    agentPackageRef: role.agentPackageRef,
+                    roleRef,
+                    workerRef,
+                    conversationLocator,
+                    listTaskIds: () => unwrap(task.queries.listTasks({})).tasks.map((summary) => summary.taskId),
+                    getRoleBindings: (candidateTaskId) => {
+                        try {
+                            return unwrap(task.queries.getTask({ taskId: candidateTaskId })).roleBindings;
+                        }
+                        catch {
+                            return null;
+                        }
+                    },
+                });
                 const [validation, currentGatewayUrl] = await Promise.all([
                     roleCarrierValidation(role.agentPackageRef),
                     currentAgentGatewayUrl(),
@@ -1445,22 +1334,14 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             }
             if (operation === "collaboration.reportDelivery") {
                 const outcome = string(value.outcome, "outcome");
-                if (outcome !== "DELIVERED" &&
-                    outcome !== "FAILED" &&
-                    outcome !== "UNKNOWN")
+                if (outcome !== "DELIVERED" && outcome !== "FAILED" && outcome !== "UNKNOWN")
                     throw new Error("COLLABORATION_DELIVERY_OUTCOME_INVALID");
                 await browserOwnerPorts.agent.reportDeliveryOutcome({
                     messageRef: string(value.messageRef, "messageRef"),
                     outcome,
-                    ...(typeof value.evidenceRef === "string"
-                        ? { evidenceRef: value.evidenceRef }
-                        : {}),
-                    ...(typeof value.executionRef === "string"
-                        ? { executionRef: value.executionRef }
-                        : {}),
-                    ...(typeof value.errorCode === "string"
-                        ? { errorCode: value.errorCode }
-                        : {}),
+                    ...(typeof value.evidenceRef === "string" ? { evidenceRef: value.evidenceRef } : {}),
+                    ...(typeof value.executionRef === "string" ? { executionRef: value.executionRef } : {}),
+                    ...(typeof value.errorCode === "string" ? { errorCode: value.errorCode } : {}),
                 });
                 return { reported: true };
             }
@@ -1484,9 +1365,8 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                 const assessmentRef = string(value.assessmentRef, "assessmentRef");
                 const observerPayload = object(value.payload, "system observer reason payload");
                 const payloadAssessmentRef = string(observerPayload.assessmentRef, "payload.assessmentRef");
-                if (payloadAssessmentRef !== assessmentRef) {
+                if (payloadAssessmentRef !== assessmentRef)
                     throw new Error("SYSTEM_OBSERVER_ASSESSMENT_REF_MISMATCH");
-                }
                 const { assessmentRef: _assessmentRef, kind, ...modelPayload } = observerPayload;
                 const response = object(await model.invoke("infer", {
                     contractVersion: "1.0.0",
@@ -1505,8 +1385,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                         : {};
                     const code = error.code === "CONTEXT_TOO_LARGE"
                         ? "CONTEXT_TOO_LARGE"
-                        : error.code === "MODEL_UNAVAILABLE" ||
-                            error.code === "CAPABILITY_UNSUPPORTED"
+                        : error.code === "MODEL_UNAVAILABLE" || error.code === "CAPABILITY_UNSUPPORTED"
                             ? "REASON_UNAVAILABLE"
                             : "REASON_FAILED";
                     return { ok: false, errorCode: code };
@@ -1528,9 +1407,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
         approvalApplication,
         observerApplication,
         async lookup(_operationId, _authenticatedRoleRef, _input) {
-            throw Object.assign(new Error("ACTION_RESULT_LOOKUP_UNSUPPORTED"), {
-                httpStatus: 409,
-            });
+            throw Object.assign(new Error("ACTION_RESULT_LOOKUP_UNSUPPORTED"), { httpStatus: 409 });
         },
         async readiness() {
             const diagnostics = taskStore.diagnostics();
@@ -1567,10 +1444,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
 }
 async function ensureRoleManagementCredential(stateRoot) {
     const path = join(stateRoot, "agent", "secrets", "role-management.token");
-    await mkdir(join(stateRoot, "agent", "secrets"), {
-        recursive: true,
-        mode: 0o700,
-    });
+    await mkdir(join(stateRoot, "agent", "secrets"), { recursive: true, mode: 0o700 });
     if (!existsSync(path)) {
         const generated = randomBytes(32).toString("base64url");
         try {
@@ -1700,17 +1574,11 @@ export function createPlatformHost(input) {
     const stoppedDependencies = () => ({
         task: { owner: "task", status: "NOT_READY", liveness: "DOWN" },
         agent: { owner: "agent", status: "NOT_READY", liveness: "DOWN" },
-        execution: {
-            owner: "execution",
-            status: "NOT_READY",
-            liveness: "DOWN",
-        },
+        execution: { owner: "execution", status: "NOT_READY", liveness: "DOWN" },
         model: { owner: "model", status: "NOT_READY", liveness: "DOWN" },
     });
     const status = async () => {
-        const dependencies = graph
-            ? await graph.readiness()
-            : stoppedDependencies();
+        const dependencies = graph ? await graph.readiness() : stoppedDependencies();
         return {
             process: lifecycle,
             liveness: lifecycle === "STOPPED" ? "DOWN" : "UP",
@@ -1808,8 +1676,7 @@ export function createPlatformHost(input) {
             modelTransportCredential = input.config.modelTransportCredentialFile
                 ? await readModelTransportCredential(input.config.modelTransportCredentialFile)
                 : undefined;
-            executionTransportCredential = input.config
-                .executionTransportCredentialFile
+            executionTransportCredential = input.config.executionTransportCredentialFile
                 ? await readExecutionTransportCredential(input.config.executionTransportCredentialFile)
                 : input.executionCredential;
             log("DEPENDENCY_INITIALIZATION_STARTED", {
@@ -1834,18 +1701,14 @@ export function createPlatformHost(input) {
                             url.pathname === "/internal/execution/identity/ready") {
                             if (!executionIdentityCredential ||
                                 !managementCredentialMatches(request.headers.authorization, executionIdentityCredential))
-                                return respond(response, 401, {
-                                    error: "EXECUTION_IDENTITY_AUTH_FAILED",
-                                });
+                                return respond(response, 401, { error: "EXECUTION_IDENTITY_AUTH_FAILED" });
                             return respond(response, 200, { ready: true });
                         }
                         if (request.method === "POST" &&
                             url.pathname === "/internal/execution/authorize") {
                             if (!executionIdentityCredential ||
                                 !managementCredentialMatches(request.headers.authorization, executionIdentityCredential))
-                                return respond(response, 401, {
-                                    error: "EXECUTION_IDENTITY_AUTH_FAILED",
-                                });
+                                return respond(response, 401, { error: "EXECUTION_IDENTITY_AUTH_FAILED" });
                             const chunks = [];
                             for await (const chunk of request)
                                 chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
@@ -1858,15 +1721,11 @@ export function createPlatformHost(input) {
                             url.pathname === "/application/approval") {
                             if (!approvalApplicationCredential ||
                                 !managementCredentialMatches(request.headers.authorization, approvalApplicationCredential))
-                                return respond(response, 401, {
-                                    error: "APPROVAL_APPLICATION_AUTH_FAILED",
-                                });
+                                return respond(response, 401, { error: "APPROVAL_APPLICATION_AUTH_FAILED" });
                             const chunks = [];
                             let bytes = 0;
                             for await (const chunk of request) {
-                                const buffer = Buffer.isBuffer(chunk)
-                                    ? chunk
-                                    : Buffer.from(chunk);
+                                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
                                 bytes += buffer.byteLength;
                                 if (bytes > 262_144)
                                     throw new TypeError("REQUEST_BODY_TOO_LARGE");
@@ -1883,19 +1742,14 @@ export function createPlatformHost(input) {
                                 });
                             }
                         }
-                        if (request.method === "POST" &&
-                            url.pathname === "/application/log") {
+                        if (request.method === "POST" && url.pathname === "/application/log") {
                             if (!taskApplicationCredential ||
                                 !managementCredentialMatches(request.headers.authorization, taskApplicationCredential))
-                                return respond(response, 401, {
-                                    error: "BROWSER_LOG_AUTH_FAILED",
-                                });
+                                return respond(response, 401, { error: "BROWSER_LOG_AUTH_FAILED" });
                             const chunks = [];
                             let bytes = 0;
                             for await (const chunk of request) {
-                                const buffer = Buffer.isBuffer(chunk)
-                                    ? chunk
-                                    : Buffer.from(chunk);
+                                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
                                 bytes += buffer.byteLength;
                                 if (bytes > 32_768)
                                     throw new TypeError("REQUEST_BODY_TOO_LARGE");
@@ -1910,25 +1764,18 @@ export function createPlatformHost(input) {
                             }
                             catch (error) {
                                 return respond(response, 400, {
-                                    error: error instanceof Error
-                                        ? error.message
-                                        : "INVALID_LOG_ENTRY",
+                                    error: error instanceof Error ? error.message : "INVALID_LOG_ENTRY",
                                 });
                             }
                         }
-                        if (request.method === "POST" &&
-                            url.pathname === "/application/observer") {
+                        if (request.method === "POST" && url.pathname === "/application/observer") {
                             if (!taskApplicationCredential ||
                                 !managementCredentialMatches(request.headers.authorization, taskApplicationCredential))
-                                return respond(response, 401, {
-                                    error: "OBSERVER_APPLICATION_AUTH_FAILED",
-                                });
+                                return respond(response, 401, { error: "OBSERVER_APPLICATION_AUTH_FAILED" });
                             const chunks = [];
                             let bytes = 0;
                             for await (const chunk of request) {
-                                const buffer = Buffer.isBuffer(chunk)
-                                    ? chunk
-                                    : Buffer.from(chunk);
+                                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
                                 bytes += buffer.byteLength;
                                 if (bytes > 262_144)
                                     throw new TypeError("REQUEST_BODY_TOO_LARGE");
@@ -1945,19 +1792,14 @@ export function createPlatformHost(input) {
                                 });
                             }
                         }
-                        if (request.method === "POST" &&
-                            url.pathname === "/application/task") {
+                        if (request.method === "POST" && url.pathname === "/application/task") {
                             if (!taskApplicationCredential ||
                                 !managementCredentialMatches(request.headers.authorization, taskApplicationCredential))
-                                return respond(response, 401, {
-                                    error: "TASK_APPLICATION_AUTH_FAILED",
-                                });
+                                return respond(response, 401, { error: "TASK_APPLICATION_AUTH_FAILED" });
                             const chunks = [];
                             let bytes = 0;
                             for await (const chunk of request) {
-                                const buffer = Buffer.isBuffer(chunk)
-                                    ? chunk
-                                    : Buffer.from(chunk);
+                                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
                                 bytes += buffer.byteLength;
                                 if (bytes > 262_144)
                                     throw new TypeError("REQUEST_BODY_TOO_LARGE");
@@ -1974,19 +1816,14 @@ export function createPlatformHost(input) {
                                 });
                             }
                         }
-                        if (request.method === "POST" &&
-                            url.pathname === "/management/agent") {
+                        if (request.method === "POST" && url.pathname === "/management/agent") {
                             if (!roleManagementCredential ||
                                 !managementCredentialMatches(request.headers.authorization, roleManagementCredential))
-                                return respond(response, 401, {
-                                    error: "MANAGEMENT_AUTH_FAILED",
-                                });
+                                return respond(response, 401, { error: "MANAGEMENT_AUTH_FAILED" });
                             const chunks = [];
                             let bytes = 0;
                             for await (const chunk of request) {
-                                const buffer = Buffer.isBuffer(chunk)
-                                    ? chunk
-                                    : Buffer.from(chunk);
+                                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
                                 bytes += buffer.byteLength;
                                 if (bytes > 65_536)
                                     throw new TypeError("REQUEST_BODY_TOO_LARGE");
@@ -2011,20 +1848,15 @@ export function createPlatformHost(input) {
                                 });
                             }
                         }
-                        if (request.method !== "POST" ||
-                            !url.pathname.startsWith("/actions/"))
+                        if (request.method !== "POST" || !url.pathname.startsWith("/actions/"))
                             return respond(response, 404, { error: "NOT_FOUND" });
                         if (gatewayTransportCredential &&
                             !managementCredentialMatches(request.headers.authorization, gatewayTransportCredential))
-                            return respond(response, 401, {
-                                error: "GATEWAY_TRANSPORT_AUTH_FAILED",
-                            });
+                            return respond(response, 401, { error: "GATEWAY_TRANSPORT_AUTH_FAILED" });
                         const chunks = [];
                         let bytes = 0;
                         for await (const chunk of request) {
-                            const buffer = Buffer.isBuffer(chunk)
-                                ? chunk
-                                : Buffer.from(chunk);
+                            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
                             bytes += buffer.byteLength;
                             if (bytes > 1_048_576)
                                 throw new TypeError("REQUEST_BODY_TOO_LARGE");
@@ -2040,12 +1872,8 @@ export function createPlatformHost(input) {
                             : await graph.route(operationId, authenticatedRoleRef, body.input, {
                                 ...(body.fileMaterializationInputs === undefined
                                     ? {}
-                                    : {
-                                        fileMaterializationInputs: body.fileMaterializationInputs,
-                                    }),
-                                ...(typeof body.deadlineAt === "string"
-                                    ? { deadlineAt: body.deadlineAt }
-                                    : {}),
+                                    : { fileMaterializationInputs: body.fileMaterializationInputs }),
+                                ...(typeof body.deadlineAt === "string" ? { deadlineAt: body.deadlineAt } : {}),
                             });
                         respond(response, 200, result);
                     }

package/dist/src/reconciliation-coordinator.js

@@ -90,7 +90,9 @@ export function createReconciliationCoordinator(options) {
     };
     const canAttempt = (taskId) => (failures.get(taskId)?.nextAt ?? 0) <= now();
     const schedulePendingRetry = (taskId) => {
-        if (stopped || !pendingSignals.has(taskId) || retryTimers.has(taskId))
+        if (stopped ||
+            (!pendingSignals.has(taskId) && !failures.has(taskId)) ||
+            retryTimers.has(taskId))
             return;
         const delay = Math.max(1, (failures.get(taskId)?.nextAt ?? now()) - now());
         const retry = setTimeout(() => {
@@ -195,7 +197,8 @@ export function createReconciliationCoordinator(options) {
             }
         })().finally(() => {
             taskInFlight.delete(taskId);
-            if (!stopped && pendingSignals.has(taskId))
+            if (!stopped &&
+                (pendingSignals.has(taskId) || failures.has(taskId)))
                 schedulePendingRetry(taskId);
             else
                 admittedTasks.delete(taskId);

package/package.json

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