@tomflow/proflow-execution-runtime 0.1.18 → 0.1.20

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @tomflow/proflow-execution-runtime
 
+## 0.1.20
+
+### Patch Changes
+
+- fix(execution-runtime): unify formal effect identity
+
+## 0.1.19
+
+### Patch Changes
+
+- Close the Real-3 runtime reconciliation, health, browser effect-result boundary, observer pagination, and standalone execution-runtime configuration gaps for final human acceptance.
+
 ## 0.1.18
 
 ### Patch Changes

package/DOCS.md

@@ -2,7 +2,7 @@
 
 ## 模块定位与作用
 
-接收标准 Execution Intent，选择 Local 或 Browser Executor，管理执行、恢复和 Evidence，并向其他领域提供唯一真实副作用入口。
+接收内部 durable Execution Intent，选择受控 Local/Browser Executor，管理执行、恢复和 Evidence；GPT-facing Repomix / Local Dev / CodeGraph Direct Tools 不进入该 lifecycle。
 
 ## 主要能力
 
@@ -17,8 +17,8 @@
 
 ## 依赖的 Module、Contract 和外部资源
 
-- 依赖 `execution-local`，兼容版本 `>=1.0.0 <2.0.0`。
-- Browser Effect 还需要 execution-browser-extension 发布的 Executor shared fact。
+- 依赖 `execution-browser-executor` 与 `execution-local`，兼容版本均为 `>=1.0.0 <2.0.0`。
+- `execution-browser-executor` 由 execution-browser-extension 发布；Execution Runtime 只消费该 Browser lane client/readiness，不拥有或关闭 Extension bridge listener。
 
 ## 运行形态与生命周期
 

package/dist/deployment/adapter.d.ts

@@ -6,7 +6,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "execution-runtime";
-            moduleVersion: "0.1.18";
+            moduleVersion: "0.1.20";
             data: {
                 endpoint: string;
                 transportCredentialFile: string;
@@ -23,7 +23,7 @@ export declare const behaviorAdapter: {
             readonly ok: true;
             readonly status: "SUCCEEDED";
             readonly moduleRef: "execution-runtime";
-            readonly moduleVersion: "0.1.18";
+            readonly moduleVersion: "0.1.20";
         };
         observedEffects: ("Persists execution state, output references and evidence in WAL SQLite" | "Runs the single backend Execution Runtime service")[];
     }>;
@@ -33,7 +33,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "execution-runtime";
-            moduleVersion: "0.1.18";
+            moduleVersion: "0.1.20";
             data: {
                 setupStatus: "READY";
                 runtimeStatus: "RUNNING" | "STOPPED";
@@ -54,7 +54,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "execution-runtime";
-            moduleVersion: "0.1.18";
+            moduleVersion: "0.1.20";
             data: {
                 endpoint: string;
                 transportCredentialFile: string;
@@ -71,7 +71,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "execution-runtime";
-            moduleVersion: "0.1.18";
+            moduleVersion: "0.1.20";
             data: {
                 docs: string;
             };
@@ -84,7 +84,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "execution-runtime";
-            moduleVersion: "0.1.18";
+            moduleVersion: "0.1.20";
             data: unknown;
         };
         observedEffects: ("Persists execution state, output references and evidence in WAL SQLite" | "Runs the single backend Execution Runtime service")[];
@@ -92,7 +92,7 @@ export declare const behaviorAdapter: {
         result: {
             contract: "deployment.result.v1";
             moduleRef: "execution-runtime";
-            moduleVersion: "0.1.18";
+            moduleVersion: "0.1.20";
             ok: false;
             status: "FAILED";
             error: {
@@ -109,7 +109,7 @@ export declare const behaviorAdapter: {
             readonly ok: true;
             readonly status: "SUCCEEDED";
             readonly moduleRef: "execution-runtime";
-            readonly moduleVersion: "0.1.18";
+            readonly moduleVersion: "0.1.20";
         };
         observedEffects: ("Persists execution state, output references and evidence in WAL SQLite" | "Runs the single backend Execution Runtime service")[];
     } | {
@@ -118,11 +118,11 @@ export declare const behaviorAdapter: {
             readonly ok: true;
             readonly status: "SUCCEEDED";
             readonly moduleRef: "execution-runtime";
-            readonly moduleVersion: "0.1.18";
+            readonly moduleVersion: "0.1.20";
         } | {
             contract: "deployment.result.v1";
             moduleRef: "execution-runtime";
-            moduleVersion: "0.1.18";
+            moduleVersion: "0.1.20";
             ok: false;
             status: "FAILED";
             error: {

package/dist/deployment/adapter.js

@@ -1,5 +1,5 @@
 import { readFileSync } from "node:fs";
-import { mkdir, readFile } from "node:fs/promises";
+import { mkdir } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { deterministicLoopbackPort, ensureModuleSecretFile, moduleWorkspaceStateDirectory, readModuleSharedFacts, writeModuleSharedFacts, } from "@tomflow/proflow-module-contract";
 import { descriptor } from "./descriptor.js";
@@ -48,45 +48,18 @@ async function readOwnFacts(context) {
         }
         : undefined;
 }
-async function baseDependencies(context) {
-    const host = await readModuleSharedFacts(context, "platform-host");
-    const model = await readModuleSharedFacts(context, "model-runtime");
-    const identityEndpoint = factString(host, "endpoint");
-    const identityTokenFile = factString(host, "identityTokenFile");
-    const modelEndpoint = factString(model, "endpoint");
-    const modelCredentialFile = factString(model, "transportCredentialFile");
-    return identityEndpoint &&
-        identityTokenFile &&
-        modelEndpoint &&
-        modelCredentialFile
-        ? {
-            identityEndpoint,
-            identityTokenFile,
-            modelEndpoint,
-            modelCredentialFile,
-        }
-        : undefined;
-}
-async function dependencies(context) {
-    const base = await baseDependencies(context);
+async function startupDependencies(context) {
     const browser = await readModuleSharedFacts(context, "execution-browser-extension");
     const browserExecutorConfigPath = factString(browser, "browserExecutorConfigPath");
-    return base && browserExecutorConfigPath
-        ? {
-            ...base,
-            browserExecutorConfigPath,
-        }
-        : undefined;
+    return browserExecutorConfigPath ? { browserExecutorConfigPath } : undefined;
 }
 async function running(context) {
     const own = await readOwnFacts(context);
     if (!own)
         return false;
     try {
-        const token = (await readFile(own.transportCredentialFile, "utf8")).trim();
-        return (await fetch(`${own.endpoint}/ready`, {
-            headers: { authorization: `Bearer ${token}` },
-            signal: AbortSignal.timeout(500),
+        return (await fetch(`${own.endpoint}/health`, {
+            signal: AbortSignal.timeout(2_000),
         })).ok;
     }
     catch {
@@ -95,31 +68,39 @@ async function running(context) {
 }
 async function compose(context) {
     const own = await ownFacts(context);
-    const deps = await dependencies(context);
-    if (!deps)
-        throw new Error("required Platform Host, Model Runtime, or Browser Executor shared facts are unavailable");
+    const browser = await readModuleSharedFacts(context, "execution-browser-extension");
+    const browserExecutorConfigPath = factString(browser, "browserExecutorConfigPath");
+    if (!browserExecutorConfigPath)
+        throw new Error("Browser Executor shared facts are unavailable");
     const [{ createFormalExecutionRuntimeLifecycle }, { parseExecutionRuntimeProcessConfig },] = await Promise.all([
         import("../src/formal-process.js"),
         import("../src/service.js"),
     ]);
     const url = new URL(own.endpoint);
     return createFormalExecutionRuntimeLifecycle({
+        resolveDependencies: async () => {
+            const host = await readModuleSharedFacts(context, "platform-host");
+            const model = await readModuleSharedFacts(context, "model-runtime");
+            const endpoint = factString(host, "endpoint"), tokenFile = factString(host, "identityTokenFile"), taskToken = factString(host, "taskApplicationTokenFile");
+            const modelEndpoint = factString(model, "endpoint"), credentialFile = factString(model, "transportCredentialFile");
+            return {
+                ...(endpoint && tokenFile ? { identity: { endpoint, tokenFile } } : {}),
+                ...(endpoint && taskToken
+                    ? { platformHost: { endpoint, tokenFile: taskToken } }
+                    : {}),
+                ...(modelEndpoint && credentialFile
+                    ? { modelDecision: { endpoint: modelEndpoint, credentialFile } }
+                    : {}),
+            };
+        },
         config: parseExecutionRuntimeProcessConfig({
             host: url.hostname,
             port: Number(url.port),
             databasePath: own.databasePath,
             projectRoot: own.projectRoot,
             artifactRoot: own.artifactRoot,
-            browserExecutorConfigPath: deps.browserExecutorConfigPath,
+            browserExecutorConfigPath,
             transportCredentialFile: own.transportCredentialFile,
-            identity: {
-                endpoint: deps.identityEndpoint,
-                tokenFile: deps.identityTokenFile,
-            },
-            modelDecision: {
-                endpoint: deps.modelEndpoint,
-                credentialFile: deps.modelCredentialFile,
-            },
             exactNetworkTargets: [],
         }),
     });
@@ -149,7 +130,7 @@ export const behaviorAdapter = {
         };
     },
     status: async (context) => {
-        const missingRuntimeDependencies = await dependencies(context);
+        const startup = await startupDependencies(context);
         return {
             result: {
                 ...base,
@@ -158,18 +139,14 @@ export const behaviorAdapter = {
                     runtimeStatus: (await running(context))
                         ? "RUNNING"
                         : "STOPPED",
-                    ...(!missingRuntimeDependencies
+                    ...(!startup
                         ? {
                             issues: [
                                 {
                                     scope: "RUNTIME",
                                     code: "UPSTREAM_NOT_READY",
-                                    message: "等待 platform-host、model-runtime 与 execution-browser-extension 发布运行所需信息",
-                                    relatedModuleRefs: [
-                                        "platform-host",
-                                        "model-runtime",
-                                        "execution-browser-extension",
-                                    ],
+                                    message: "等待 execution-browser-extension 发布 Browser Executor client 配置",
+                                    relatedModuleRefs: ["execution-browser-extension"],
                                     nextCommand: "platform setup",
                                 },
                             ],

package/dist/deployment/descriptor.d.ts

@@ -3,7 +3,7 @@ export declare const descriptor: {
     readonly contractVersion: "1.0.0";
     readonly moduleRef: "execution-runtime";
     readonly packageName: "@tomflow/proflow-execution-runtime";
-    readonly moduleVersion: "0.1.18";
+    readonly moduleVersion: "0.1.20";
     readonly kind: "service";
     readonly templateVersion: "1.0.0";
     readonly platformCompatibility: ">=1.0.0 <2.0.0";
@@ -16,6 +16,9 @@ export declare const descriptor: {
         readonly version: "1.0.0";
     }];
     readonly requires: readonly [{
+        readonly contractRef: "execution-browser-executor";
+        readonly versionRange: ">=1.0.0 <2.0.0";
+    }, {
         readonly contractRef: "execution-local";
         readonly versionRange: ">=1.0.0 <2.0.0";
     }];

package/dist/deployment/descriptor.js

@@ -3,7 +3,7 @@ export const descriptor = {
     contractVersion: "1.0.0",
     moduleRef: "execution-runtime",
     packageName: "@tomflow/proflow-execution-runtime",
-    moduleVersion: "0.1.18",
+    moduleVersion: "0.1.20",
     kind: "service",
     templateVersion: "1.0.0",
     platformCompatibility: ">=1.0.0 <2.0.0",
@@ -18,6 +18,10 @@ export const descriptor = {
         },
     ],
     requires: [
+        {
+            contractRef: "execution-browser-executor",
+            versionRange: ">=1.0.0 <2.0.0",
+        },
         {
             contractRef: "execution-local",
             versionRange: ">=1.0.0 <2.0.0",

package/dist/src/formal-process.d.ts

@@ -2,6 +2,11 @@ import { type ExecutionRuntimeProcessConfig } from "./service.ts";
 export declare function createFormalExecutionRuntimeLifecycle(input: {
     config: ExecutionRuntimeProcessConfig;
     log?: (entry: Record<string, unknown>) => void;
+    resolveDependencies?: () => Promise<{
+        identity?: ExecutionRuntimeProcessConfig["identity"];
+        modelDecision?: ExecutionRuntimeProcessConfig["modelDecision"];
+        platformHost?: ExecutionRuntimeProcessConfig["platformHost"];
+    }>;
 }): Readonly<{
     status: () => import("./service.ts").ExecutionRuntimeProcessStatus | {
         readiness: "NOT_READY";

package/dist/src/formal-process.js

@@ -1,5 +1,5 @@
 import { readFile, stat } from "node:fs/promises";
-import { createBrowserExecutorComposition, loadBrowserExecutorCompositionConfig, } from "@tomflow/proflow-execution-browser-extension/runtime-composition";
+import { createBrowserExecutorClientComposition } from "@tomflow/proflow-execution-browser-extension/runtime-composition";
 import { createExecutionBrowserVisionClient } from "./browser-vision-client.js";
 import { createExecutionModelDecisionClient } from "./model-decision-client.js";
 import { createExecutionRuntimeProcess, } from "./service.js";
@@ -28,7 +28,6 @@ async function createIdentityClient(config) {
         }
         return ready;
     };
-    await probe();
     return {
         port: {
             async authorize(request) {
@@ -56,45 +55,81 @@ async function createIdentityClient(config) {
     };
 }
 function assertFormalConfig(config) {
-    if (!config.identity)
-        throw new Error("formal execution-runtime requires identity configuration");
     if (!config.transportCredentialFile)
         throw new Error("formal execution-runtime requires transportCredentialFile");
     if (!config.browserExecutorConfigPath)
         throw new Error("formal execution-runtime requires browserExecutorConfigPath");
-    if (!config.modelDecision)
-        throw new Error("formal execution-runtime requires modelDecision configuration");
-    if (!config.modelDecision.credentialFile)
-        throw new Error("formal execution-runtime requires modelDecision.credentialFile");
     return {
         identity: config.identity,
         transportCredentialFile: config.transportCredentialFile,
         browserExecutorConfigPath: config.browserExecutorConfigPath,
-        modelDecision: {
-            ...config.modelDecision,
-            credentialFile: config.modelDecision.credentialFile,
-        },
     };
 }
 export function createFormalExecutionRuntimeLifecycle(input) {
     const required = assertFormalConfig(input.config);
+    if (!input.resolveDependencies && !input.config.platformHost)
+        throw new Error("formal execution-runtime requires platformHost or resolveDependencies");
     let current;
     const build = async () => {
-        const identityClient = await createIdentityClient(required.identity);
+        const dependencies = input.resolveDependencies ??
+            (async () => ({
+                identity: input.config.identity,
+                modelDecision: input.config.modelDecision,
+                platformHost: input.config.platformHost,
+            }));
+        let identityReady = false;
+        let modelReady = false;
+        const resolveIdentity = async () => {
+            const config = (await dependencies()).identity;
+            if (!config)
+                throw new Error("EXECUTION_IDENTITY_UNAVAILABLE");
+            return createIdentityClient(config);
+        };
+        const modelConfig = async () => {
+            const config = (await dependencies()).modelDecision;
+            if (!config?.credentialFile)
+                throw new Error("MODEL_DECISION_UNAVAILABLE");
+            return {
+                ...config,
+                credential: await readSecret(config.credentialFile, "model credential"),
+            };
+        };
         const transportCredential = await readSecret(required.transportCredentialFile, "execution transport credential");
-        const modelDecisionCredential = await readSecret(required.modelDecision.credentialFile, "model decision transport credential");
-        const modelDecisionClient = createExecutionModelDecisionClient({
-            endpoint: required.modelDecision.endpoint,
-            ...(required.modelDecision.timeoutMs === undefined
-                ? {}
-                : { timeoutMs: required.modelDecision.timeoutMs }),
-            credential: modelDecisionCredential,
+        const browserComposition = await createBrowserExecutorClientComposition({
+            configPath: required.browserExecutorConfigPath,
+            platformHost: async () => {
+                const config = (await dependencies()).platformHost;
+                if (!config)
+                    throw new Error("PLATFORM_HOST_APPLICATION_UNAVAILABLE");
+                return {
+                    endpoint: config.endpoint,
+                    token: await readSecret(config.tokenFile, "task application credential"),
+                };
+            },
+            vision: {
+                inspect: async (request) => createExecutionBrowserVisionClient(await modelConfig()).port.inspect(request),
+            },
         });
         let dependencyRefresh;
         const refreshDependencies = () => {
             dependencyRefresh ??= Promise.allSettled([
-                identityClient.probe(),
-                modelDecisionClient.probe(),
+                resolveIdentity()
+                    .then((client) => client.probe())
+                    .then((ready) => {
+                    identityReady = ready;
+                })
+                    .catch(() => {
+                    identityReady = false;
+                }),
+                modelConfig()
+                    .then((config) => createExecutionModelDecisionClient(config).probe())
+                    .then((ready) => {
+                    modelReady = ready;
+                })
+                    .catch(() => {
+                    modelReady = false;
+                }),
+                browserComposition.refreshStatus(),
             ])
                 .then(() => undefined)
                 .finally(() => {
@@ -102,27 +137,35 @@ export function createFormalExecutionRuntimeLifecycle(input) {
             });
             return dependencyRefresh;
         };
-        await refreshDependencies();
-        const browserVisionClient = createExecutionBrowserVisionClient({
-            endpoint: required.modelDecision.endpoint,
-            ...(required.modelDecision.timeoutMs === undefined
-                ? {}
-                : { timeoutMs: required.modelDecision.timeoutMs }),
-            credential: modelDecisionCredential,
-        });
-        const browserComposition = await createBrowserExecutorComposition({
-            ...(await loadBrowserExecutorCompositionConfig(required.browserExecutorConfigPath)),
-            vision: browserVisionClient.port,
-        });
         try {
             const service = await createExecutionRuntimeProcess({
                 config: input.config,
-                identity: identityClient.port,
-                identityReadiness: identityClient.readiness,
+                identity: {
+                    authorize: async (request) => {
+                        try {
+                            const client = await resolveIdentity();
+                            const allowed = await client.port.authorize(request);
+                            identityReady = client.readiness();
+                            return allowed;
+                        }
+                        catch {
+                            identityReady = false;
+                            return false;
+                        }
+                    },
+                },
+                identityReadiness: () => identityReady,
                 transportCredential,
                 requireModelDecision: true,
-                modelDecision: modelDecisionClient.port,
-                modelDecisionReadiness: modelDecisionClient.readiness,
+                modelDecision: {
+                    decide: async (request, context) => {
+                        const client = createExecutionModelDecisionClient(await modelConfig());
+                        await client.probe();
+                        modelReady = client.readiness();
+                        return client.port.decide(request, context);
+                    },
+                },
+                modelDecisionReadiness: () => modelReady,
                 refreshDependencies,
                 browserExecutor: browserComposition.browserExecutor,
                 browserReadiness: () => browserComposition.bridgeStatus().online,

package/dist/src/index.d.ts

@@ -1,4 +1,4 @@
-import { type ExecuteCapabilityRequest, type ExecutionArtifactRecord, type ExecutionErrorCode, type ExecutionRecord, type ReadExecutionOutputResponse } from "@tomflow/proflow-execution-contracts";
+import { type ExecuteCapabilityRequest, type ExecutionArtifactRecord, type ExecutionErrorCode, type ExecutionRecord, type MonitorEffectReceipt, type ReadExecutionOutputResponse } from "@tomflow/proflow-execution-contracts";
 import type { ExecutionExecutorPort, ExecutorPrecondition } from "./executor-port.ts";
 export declare const moduleRef: "execution-runtime";
 type MaybePromise<Value> = Value | Promise<Value>;
@@ -62,6 +62,7 @@ export declare class ExecutionRuntimeError extends Error {
 export declare function executionInputFingerprint(input: unknown): string;
 export declare function createExecutionRuntime(options: ExecutionRuntimeOptions): Promise<Readonly<{
     executeCapability: (input: unknown) => Promise<ExecutionRecord>;
+    executeEffect: (input: unknown) => Promise<MonitorEffectReceipt>;
     lookupExecutionIntent: (input: unknown) => ExecutionRecord;
     listExecutionObserverSignals: (limit?: number) => {
         signalRef: string;

package/dist/src/index.js

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { appendFile, mkdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { DatabaseSync } from "node:sqlite";
-import { browserCapabilityIds, EXECUTION_CONTRACT_VERSION, executionErrorCodes, parseCancelExecutionRequest, parseExecuteCapabilityRequest, parseExecutionArtifactRecord, parseExecutionRecord, parseExecutionRef, parseReadExecutionOutputRequest, } from "@tomflow/proflow-execution-contracts";
+import { browserCapabilityIds, EXECUTION_CONTRACT_VERSION, executionErrorCodes, parseCancelExecutionRequest, parseExecuteCapabilityRequest, parseExecutionArtifactRecord, parseExecutionRecord, parseMonitorEffectRequest, parseMonitorEffectReceipt, parseExecutionRef, parseReadExecutionOutputRequest, } from "@tomflow/proflow-execution-contracts";
 import { createExecutionApprovalOwner } from "./approval-owner.js";
 export const moduleRef = "execution-runtime";
 export class ExecutionRuntimeError extends Error {
@@ -17,6 +17,12 @@ export class ExecutionRuntimeError extends Error {
 }
 const sensitive = /(?:authorization|bearer|api[_-]?key|token|password|cookie|private[_-]?key|secret)/i;
 const browserIds = new Set(browserCapabilityIds);
+const formalEffectCapabilities = new Set([
+    "monitor.chat.create",
+    "monitor.chat.submit",
+    "browser.action",
+]);
+const isFormalEffectCapability = (capability) => formalEffectCapabilities.has(capability);
 function canonical(value) {
     if (Array.isArray(value))
         return value.map(canonical);
@@ -39,7 +45,7 @@ function scrubEmbeddedSecrets(value) {
         .replace(/((?:authorization|api[_-]?key|token|password|cookie|secret|private[_-]?key)\s*[:=]\s*)([^\s,;"'}]+)/gi, (_match, prefix, secretValue) => typeof prefix === "string" && typeof secretValue === "string"
         ? `${prefix}[SECRET_REF:${sha(secretValue)}]`
         : _match)
-        .replace(/("(?:password|token|secret|api[_-]?key|authorization|cookie|private[_-]?key)"\s*:\s*")((?:[^"\\]|\\.)*)(")/gi, (_match, prefix, secretValue, suffix) => typeof prefix === "string" &&
+        .replace(/("[A-Za-z0-9_-]*(?:password|token|secret|api[_-]?key|authorization|cookie|private[_-]?key)[A-Za-z0-9_-]*"\s*:\s*")((?:[^"\\]|\\.)*)(")/gi, (_match, prefix, secretValue, suffix) => typeof prefix === "string" &&
         typeof secretValue === "string" &&
         typeof suffix === "string"
         ? `${prefix}[SECRET_REF:${sha(secretValue)}]${suffix}`
@@ -62,13 +68,11 @@ function protectedValue(value, key = "") {
                 continue;
             }
             if (flag[1] !== undefined && flag[1].length > 0) {
-                // `--token=value` — keep the flag, hash the value.
                 items.push(`${item.slice(0, item.length - flag[1].length)}[SECRET_REF:${sha(flag[1])}]`);
             }
             else {
                 items.push(item);
                 if (i + 1 < value.length) {
-                    // `--token value` — the following positional arg is the secret.
                     items.push(`[SECRET_REF:${sha(value[i + 1])}]`);
                     i++;
                 }
@@ -84,11 +88,20 @@ function protectedValue(value, key = "") {
         protectedValue(item, childKey),
     ]));
 }
+function stableEffectInput(request) {
+    if (request.capability !== "monitor.chat.submit" && request.capability !== "monitor.chat.create")
+        return request.input;
+    const effect = { ...request.input };
+    // Legacy revision fences are admission facts, not physical-effect identity.
+    delete effect.expectedRunVersion;
+    delete effect.configRevision;
+    return effect;
+}
 export function executionInputFingerprint(input) {
     const request = parseExecuteCapabilityRequest(input);
     return sha({
         capability: request.capability,
-        input: protectedValue(request.input),
+        input: protectedValue(stableEffectInput(request)),
         callerRef: request.callerRef,
         taskId: request.taskId,
         nodeId: request.nodeId,
@@ -118,6 +131,20 @@ function compatibleDurableInputFingerprint(row, request, currentFingerprint) {
     try {
         const durableRequest = parseExecuteCapabilityRequest(JSON.parse(String(row.request_json)));
         const durableRecord = parseExecutionRecord(JSON.parse(String(row.record_json)));
+        if ((request.capability === "monitor.chat.submit" || request.capability === "monitor.chat.create") &&
+            durableRequest.capability === request.capability &&
+            sha({
+                capability: durableRequest.capability,
+                input: stableEffectInput(durableRequest),
+                callerRef: durableRequest.callerRef,
+                taskId: durableRequest.taskId,
+                nodeId: durableRequest.nodeId,
+                runNo: durableRequest.runNo,
+                roleRef: durableRequest.roleRef,
+                workerRef: durableRequest.workerRef,
+                projectRoot: durableRequest.projectRoot,
+            }) === currentFingerprint)
+            return durableFingerprint;
         if (durableFingerprint === legacyExecutionInputFingerprint(request) &&
             durableRequest.runNo === request.runNo &&
             durableRecord.runNo === request.runNo)
@@ -153,6 +180,10 @@ function runtimeError(error) {
 }
 const defaultPolicy = {
     decide(request) {
+        const trustedSystemEffect = request.capability === "product.discussion.bootstrap.deliver" ||
+            request.capability === "product.review.deliver" ||
+            request.capability === "monitor.chat.submit" ||
+            request.capability === "monitor.chat.create" || request.capability === "browser.action";
         const readOnly = request.capability === "file.read" ||
             request.capability === "file.searchText" ||
             request.capability === "artifact.external-file.materialize" ||
@@ -169,14 +200,12 @@ const defaultPolicy = {
             request.capability === "browser.verify" ||
             (request.capability === "network.request" &&
                 (request.input.method === "GET" || request.input.method === "HEAD"));
-        if (readOnly)
+        if (readOnly || trustedSystemEffect)
             return {
                 decision: "ALLOW",
                 decisionPath: "deterministic",
                 approvalRequired: false,
             };
-        // Frozen policy: every ordinary real side effect is semantically judged by
-        // FAST first. REASON/Human are escalation paths, never a blanket gate.
         return {
             decision: "REVIEW",
             decisionPath: "fast",
@@ -220,6 +249,9 @@ export async function createExecutionRuntime(options) {
 			record_json TEXT NOT NULL, precondition_json TEXT, created_at TEXT NOT NULL,
 			UNIQUE(caller_ref, capability, idempotency_key)
 		);
+		CREATE UNIQUE INDEX IF NOT EXISTS formal_effect_identity
+			ON executions(idempotency_key)
+			WHERE capability IN ('monitor.chat.create', 'monitor.chat.submit', 'browser.action');
 		CREATE TABLE IF NOT EXISTS execution_artifacts (
 			execution_ref TEXT NOT NULL, artifact_ref TEXT NOT NULL, stream TEXT NOT NULL, path TEXT NOT NULL,
 			PRIMARY KEY(execution_ref, artifact_ref), FOREIGN KEY(execution_ref) REFERENCES executions(execution_ref)
@@ -324,6 +356,12 @@ export async function createExecutionRuntime(options) {
         updatedAt: now().toISOString(),
     });
     async function admit(request, inputFingerprint, executionRef) {
+        const trustedSystemEffect = request.capability === "product.discussion.bootstrap.deliver" ||
+            request.capability === "product.review.deliver" ||
+            request.capability === "monitor.chat.submit" ||
+            request.capability === "monitor.chat.create" || request.capability === "browser.action";
+        if (trustedSystemEffect && !options.identity)
+            throw new ExecutionRuntimeError("IDENTITY_INVALID", "trusted system effect requires an authoritative identity port");
         if (options.identity && !(await options.identity.authorize(request)))
             throw new ExecutionRuntimeError("IDENTITY_INVALID", "caller, Task, Agent, workspace, or Browser identity is not authoritative");
         const policy = options.policy ?? defaultPolicy;
@@ -532,10 +570,96 @@ export async function createExecutionRuntime(options) {
             throw new ExecutionRuntimeError("IDEMPOTENCY_CONFLICT", "execution intent lookup input does not match durable input");
         return fromRow(row);
     }
+    async function reconcileUnknownReplay(request, row, prior) {
+        const executor = browserIds.has(request.capability)
+            ? options.browserExecutor
+            : options.localExecutor;
+        const preconditionRaw = row.precondition_json;
+        if (!executor || !preconditionRaw) {
+            await log(prior, "UNKNOWN_REPLAY_UNRESOLVED", prior.error?.code);
+            return prior;
+        }
+        try {
+            const reconciliation = await executor.reconcile(request, JSON.parse(String(preconditionRaw)));
+            let reconciled;
+            if (reconciliation.state === "NOT_APPLIED") {
+                const failed = failRecord(prior, new ExecutionRuntimeError("EXECUTION_FAILED", "replay reconciliation verified no effect"));
+                reconciled = parseExecutionRecord({
+                    ...failed,
+                    evidence: reconciliation.evidence,
+                    evidenceRefs: reconciliation.evidence.map((item) => item.evidenceRef),
+                });
+            }
+            else if (reconciliation.state === "APPLIED" && reconciliation.result) {
+                const { error: _previousError, ...recoverable } = prior;
+                reconciled = parseExecutionRecord({
+                    ...recoverable,
+                    status: "SUCCEEDED",
+                    sideEffectState: "APPLIED",
+                    retryable: false,
+                    result: reconciliation.result,
+                    evidence: reconciliation.evidence,
+                    evidenceRefs: reconciliation.evidence.map((item) => item.evidenceRef),
+                    finishedAt: now().toISOString(),
+                    updatedAt: now().toISOString(),
+                });
+            }
+            else {
+                await log(prior, "UNKNOWN_REPLAY_UNRESOLVED", prior.error?.code);
+                return prior;
+            }
+            const updated = database.prepare("UPDATE executions SET record_json=? WHERE execution_ref=? AND record_json=?").run(JSON.stringify(reconciled), prior.executionRef, String(row.record_json));
+            if (updated.changes !== 1) {
+                const current = getRow(prior.executionRef);
+                return current ? fromRow(current) : prior;
+            }
+            await log(reconciled, "UNKNOWN_REPLAY_RECONCILED", reconciled.error?.code);
+            emitObserverSignal(reconciled, "RECOVERY_RESUME");
+            return reconciled;
+        }
+        catch {
+            await log(prior, "UNKNOWN_REPLAY_UNRESOLVED", prior.error?.code);
+            return prior;
+        }
+    }
+    async function executeEffect(input) {
+        const { effectId, action, request } = parseMonitorEffectRequest(input);
+        const existingEffect = database
+            .prepare("SELECT * FROM executions WHERE idempotency_key=? AND capability IN ('monitor.chat.create', 'monitor.chat.submit', 'browser.action') ORDER BY created_at, execution_ref LIMIT 1")
+            .get(effectId);
+        let ownerRequest = request;
+        if (existingEffect) {
+            if (String(existingEffect.capability) !== action)
+                throw new ExecutionRuntimeError("IDEMPOTENCY_CONFLICT", "effectId already belongs to another action");
+            if (String(existingEffect.caller_ref) !== request.callerRef)
+                ownerRequest = parseExecuteCapabilityRequest({
+                    ...request,
+                    callerRef: String(existingEffect.caller_ref),
+                });
+            if (compatibleDurableInputFingerprint(existingEffect, ownerRequest, executionInputFingerprint(ownerRequest)) === undefined)
+                throw new ExecutionRuntimeError("IDEMPOTENCY_CONFLICT", "effectId already belongs to different critical input");
+        }
+        const record = await executeCapability(ownerRequest);
+        const state = record.sideEffectState === "APPLIED"
+            ? "APPLIED"
+            : record.sideEffectState === "NOT_APPLIED"
+                ? "NOT_APPLIED"
+                : "PENDING";
+        return parseMonitorEffectReceipt({
+            effectId,
+            action,
+            state,
+            executionRef: record.executionRef,
+            ...(state === "APPLIED" && record.result
+                ? { result: record.result }
+                : {}),
+        });
+    }
     async function executeCapability(input) {
         if (closed)
             throw new ExecutionRuntimeError("EXECUTOR_UNAVAILABLE", "execution runtime is closed");
         const request = parseExecuteCapabilityRequest(input);
+        const monitorEffect = isFormalEffectCapability(request.capability);
         assertPatchArtifactScope(request);
         let inputFingerprint = executionInputFingerprint(request);
         const existing = database
@@ -548,8 +672,16 @@ export async function createExecutionRuntime(options) {
                 throw new ExecutionRuntimeError("IDEMPOTENCY_CONFLICT", "idempotency key was already used with different critical input");
             inputFingerprint = durableFingerprint;
             const prior = fromRow(existing);
-            const safelyResumable = (prior.status === "PENDING" &&
-                prior.sideEffectState === "NOT_STARTED") ||
+            // Existing PENDING and APPLIED are read-only. Only proven absence permits retry.
+            if (monitorEffect && prior.sideEffectState !== "NOT_APPLIED")
+                return prior;
+            if (prior.status === "UNKNOWN" && prior.sideEffectState === "UNKNOWN" &&
+                (request.capability === "product.discussion.bootstrap.deliver" ||
+                    request.capability === "product.review.deliver"))
+                return reconcileUnknownReplay(request, existing, prior);
+            const safelyResumable = (monitorEffect && prior.sideEffectState === "NOT_APPLIED") ||
+                (prior.status === "PENDING" &&
+                    prior.sideEffectState === "NOT_STARTED") ||
                 (prior.status === "FAILED" && prior.sideEffectState === "NOT_APPLIED");
             if (!safelyResumable)
                 return prior;
@@ -561,9 +693,11 @@ export async function createExecutionRuntime(options) {
                 retryable: false,
                 updatedAt: now().toISOString(),
             });
-            database
-                .prepare("UPDATE executions SET request_json=?, record_json=?, precondition_json=NULL WHERE execution_ref=?")
-                .run(JSON.stringify(protectedValue(request)), JSON.stringify(record), record.executionRef);
+            const claimed = database
+                .prepare("UPDATE executions SET request_json=?, record_json=?, precondition_json=NULL WHERE execution_ref=? AND record_json=?")
+                .run(JSON.stringify(protectedValue(request)), JSON.stringify(record), record.executionRef, String(existing.record_json));
+            if (claimed.changes === 0)
+                return fromRow(getRow(record.executionRef));
             await log(record, "EXECUTION_REDECISION_REQUESTED");
         }
         else {
@@ -658,9 +792,6 @@ export async function createExecutionRuntime(options) {
                 throw new ExecutionRuntimeError(timedOut ? "TIMEOUT" : "CANCELLED", timedOut
                     ? "execution runtime timeout elapsed during admission"
                     : "execution was cancelled during admission");
-            // CAS: only transition to RUNNING if the record is still PENDING.
-            // A concurrent cancel/timeout finalizes PENDING records, so a
-            // stale RUNNING write would silently resurrect a cancelled intent.
             const casRow = getRow(record.executionRef);
             if (casRow) {
                 const casRecord = fromRow(casRow);
@@ -812,7 +943,12 @@ export async function createExecutionRuntime(options) {
             const row = getRow(record.executionRef);
             if (row)
                 record = fromRow(row);
-            if (record.sideEffectState === "STARTED") {
+            if (monitorEffect && record.sideEffectState === "APPLIED")
+                return record;
+            if (monitorEffect && record.sideEffectState === "STARTED") {
+                record = failRecord(record, failure, "UNKNOWN");
+            }
+            else if (record.sideEffectState === "STARTED") {
                 const executor = browserIds.has(request.capability)
                     ? options.browserExecutor
                     : options.localExecutor;
@@ -914,6 +1050,10 @@ export async function createExecutionRuntime(options) {
         let record = getExecutionRecord(request.executionRef);
         if (record.callerRef !== request.callerRef)
             throw new ExecutionRuntimeError("IDENTITY_INVALID", "only the bound caller may cancel execution");
+        // Admission may still be in flight. Cancellation cannot prove it has stopped,
+        // so it must not expose NOT_APPLIED and let another caller claim this row.
+        if (isFormalEffectCapability(record.capability) && record.status === "PENDING")
+            throw new ExecutionRuntimeError("INVALID_REQUEST", "Monitor PENDING must settle through effect.execute");
         controllers.get(request.executionRef)?.abort();
         if (record.status === "PENDING") {
             record = failRecord(record, new ExecutionRuntimeError("CANCELLED", request.reason));
@@ -926,6 +1066,8 @@ export async function createExecutionRuntime(options) {
         const rows = database.prepare("SELECT * FROM executions").all();
         for (const row of rows) {
             let record = fromRow(row);
+            if (isFormalEffectCapability(record.capability))
+                continue;
             if (record.status !== "PENDING" &&
                 record.status !== "RUNNING" &&
                 record.status !== "UNKNOWN")
@@ -986,6 +1128,7 @@ export async function createExecutionRuntime(options) {
     await recoverIncomplete();
     return Object.freeze({
         executeCapability,
+        executeEffect,
         lookupExecutionIntent,
         listExecutionObserverSignals,
         acknowledgeExecutionObserverSignal,

package/dist/src/service.d.ts

@@ -12,6 +12,10 @@ export type ExecutionRuntimeProcessConfig = {
         endpoint: string;
         tokenFile: string;
     };
+    platformHost?: {
+        endpoint: string;
+        tokenFile: string;
+    };
     modelDecision?: {
         endpoint: string;
         timeoutMs?: number;

package/dist/src/service.js

@@ -2,6 +2,7 @@ import { timingSafeEqual } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { createServer } from "node:http";
 import { dirname, isAbsolute, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
 import { artifactMaterializationResponseSchema, EXECUTION_CONTRACT_VERSION, materializeContextPackRequestSchema, materializeExternalFilesRequestSchema, materializeExternalFilesResponseSchema, materializePatchProposalRequestSchema, parseExecutionRef, } from "@tomflow/proflow-execution-contracts";
 import { createLocalExecutorPort } from "./executors/local-adapter.js";
 import { createExecutionRuntime, } from "./index.js";
@@ -15,6 +16,22 @@ function string(value, name) {
         throw new TypeError(`${name} must be a non-empty string`);
     return value;
 }
+function parseLoopbackOwner(value, name) {
+    const input = object(value, name);
+    const endpoint = new URL(string(input.endpoint, `${name}.endpoint`));
+    if (endpoint.protocol !== "http:" ||
+        !new Set(["127.0.0.1", "localhost", "::1", "[::1]"]).has(endpoint.hostname) ||
+        endpoint.pathname !== "/" ||
+        endpoint.username ||
+        endpoint.password ||
+        endpoint.search ||
+        endpoint.hash)
+        throw new TypeError(`${name}.endpoint must be loopback HTTP root`);
+    const tokenFile = string(input.tokenFile, `${name}.tokenFile`);
+    if (!isAbsolute(tokenFile))
+        throw new TypeError(`${name}.tokenFile must be absolute`);
+    return { endpoint: endpoint.origin, tokenFile };
+}
 export function parseExecutionRuntimeProcessConfig(value) {
     const input = object(value, "execution-runtime config");
     const databasePath = resolve(string(input.databasePath, "databasePath"));
@@ -63,21 +80,12 @@ export function parseExecutionRuntimeProcessConfig(value) {
             ...(credentialFile === undefined ? {} : { credentialFile }),
         };
     }
-    let identity;
-    if (input.identity !== undefined) {
-        const value = object(input.identity, "identity");
-        const endpoint = new URL(string(value.endpoint, "identity.endpoint"));
-        if (endpoint.protocol !== "http:" ||
-            !new Set(["127.0.0.1", "localhost", "::1", "[::1]"]).has(endpoint.hostname) ||
-            endpoint.pathname !== "/" ||
-            endpoint.search ||
-            endpoint.hash)
-            throw new TypeError("identity.endpoint must be loopback HTTP root");
-        const tokenFile = string(value.tokenFile, "identity.tokenFile");
-        if (!isAbsolute(tokenFile))
-            throw new TypeError("identity.tokenFile must be absolute");
-        identity = { endpoint: endpoint.origin, tokenFile };
-    }
+    const identity = input.identity === undefined
+        ? undefined
+        : parseLoopbackOwner(input.identity, "identity");
+    const platformHost = input.platformHost === undefined
+        ? undefined
+        : parseLoopbackOwner(input.platformHost, "platformHost");
     if (!Array.isArray(exactNetworkTargets) ||
         exactNetworkTargets.some((item) => typeof item !== "string"))
         throw new TypeError("exactNetworkTargets must be a string array");
@@ -91,12 +99,57 @@ export function parseExecutionRuntimeProcessConfig(value) {
         ...(browserExecutorConfigPath ? { browserExecutorConfigPath } : {}),
         ...(transportCredentialFile ? { transportCredentialFile } : {}),
         ...(identity ? { identity } : {}),
+        ...(platformHost ? { platformHost } : {}),
         ...(modelDecision ? { modelDecision } : {}),
     };
 }
 export async function loadExecutionRuntimeProcessConfig(path) {
     return parseExecutionRuntimeProcessConfig(JSON.parse(await readFile(resolve(path), "utf8")));
 }
+function createObserverSignalPager(databasePath) {
+    const database = new DatabaseSync(databasePath, { readOnly: true });
+    let cursor;
+    let upperBound;
+    const page = (limit, after) => {
+        if (!upperBound)
+            return [];
+        return database.prepare(`SELECT record_json, created_at, signal_ref FROM execution_observer_signals
+			 WHERE acknowledged_at IS NULL
+			 AND (created_at, signal_ref) <= (?, ?)
+			 ${after ? "AND (created_at, signal_ref) > (?, ?)" : ""}
+			 ORDER BY created_at, signal_ref LIMIT ?`).all(upperBound.createdAt, upperBound.signalRef, ...(after ? [after.createdAt, after.signalRef] : []), limit);
+    };
+    const beginCycle = () => {
+        cursor = undefined;
+        const last = database.prepare("SELECT created_at, signal_ref FROM execution_observer_signals WHERE acknowledged_at IS NULL ORDER BY created_at DESC, signal_ref DESC LIMIT 1").get();
+        upperBound = last ? {
+            createdAt: String(last.created_at), signalRef: String(last.signal_ref),
+        } : undefined;
+    };
+    return Object.freeze({
+        list(limit = 50) {
+            const normalized = Number.isFinite(limit) ? Math.trunc(limit) : 50;
+            const bounded = Math.max(1, Math.min(100, normalized));
+            if (!upperBound)
+                beginCycle();
+            let rows = page(bounded, cursor);
+            if (rows.length === 0) {
+                beginCycle();
+                rows = page(bounded);
+            }
+            const last = rows.at(-1);
+            if (last)
+                cursor = {
+                    createdAt: String(last.created_at),
+                    signalRef: String(last.signal_ref),
+                };
+            return rows.map((row) => JSON.parse(String(row.record_json)));
+        },
+        close() {
+            database.close();
+        },
+    });
+}
 export async function createExecutionRuntimeProcess(input) {
     if (input.transportCredential && input.transportCredential.length < 32)
         throw new TypeError("transport credential must contain at least 32 characters");
@@ -104,6 +157,7 @@ export async function createExecutionRuntimeProcess(input) {
     let accepting = false;
     let server;
     let runtime;
+    let observerSignals;
     const active = new Set();
     const log = (event, fields = {}) => input.log?.({
         timestamp: new Date().toISOString(),
@@ -117,29 +171,29 @@ export async function createExecutionRuntimeProcess(input) {
                 ? "UNAVAILABLE"
                 : "READY"
             : "UNAVAILABLE";
-        const browserRequirementSatisfied = input.config.browserExecutorConfigPath === undefined ||
-            browserExecutor === "READY";
         const identity = input.identity && input.identityReadiness?.() !== false
             ? "READY"
             : "UNAVAILABLE";
-        const identityRequirementSatisfied = input.config.identity === undefined || identity === "READY";
         const transportAuth = input.transportCredential ? "READY" : "UNAVAILABLE";
         const transportRequirementSatisfied = input.config.transportCredentialFile === undefined ||
             transportAuth === "READY";
         const modelDecision = input.modelDecision && input.modelDecisionReadiness?.() !== false
             ? "READY"
             : "UNAVAILABLE";
-        const modelRequirementSatisfied = input.requireModelDecision !== true || modelDecision === "READY";
+        const browserRequirementSatisfied = input.browserExecutor === undefined || browserExecutor === "READY";
+        const identityRequirementSatisfied = (input.identity === undefined && input.config.identity === undefined) ||
+            identity === "READY";
+        const modelDecisionRequirementSatisfied = input.requireModelDecision !== true || modelDecision === "READY";
         return {
             process: state,
             liveness: state === "STOPPED" ? "DOWN" : "UP",
             readiness: state === "RUNNING" &&
                 accepting &&
                 runtime &&
+                transportRequirementSatisfied &&
                 browserRequirementSatisfied &&
                 identityRequirementSatisfied &&
-                transportRequirementSatisfied &&
-                modelRequirementSatisfied
+                modelDecisionRequirementSatisfied
                 ? "READY"
                 : "NOT_READY",
             accepting,
@@ -180,6 +234,7 @@ export async function createExecutionRuntimeProcess(input) {
                 ...(input.modelDecision ? { modelDecision: input.modelDecision } : {}),
                 ...(input.approval ? { approval: input.approval } : {}),
             });
+            observerSignals = createObserverSignalPager(input.config.databasePath);
             server = createServer((request, response) => {
                 const work = (async () => {
                     const url = new URL(request.url ?? "/", "http://execution.local");
@@ -187,12 +242,12 @@ export async function createExecutionRuntimeProcess(input) {
                         return respond(response, 200, { status: "UP" });
                     if (request.method === "GET" && url.pathname === "/ready") {
                         let current = status();
-                        if (current.readiness !== "READY" && input.refreshDependencies) {
+                        if (input.refreshDependencies) {
                             try {
                                 await input.refreshDependencies();
                             }
                             catch {
-                                // Keep readiness fail-closed when the bounded dependency re-probe fails.
+                                // Owner readiness is reported separately from process readiness.
                             }
                             current = status();
                         }
@@ -386,6 +441,8 @@ export async function createExecutionRuntimeProcess(input) {
                         if (request.method === "GET" &&
                             url.pathname.startsWith("/approvals/"))
                             return respond(response, 200, runtime.getExecutionApproval(decodeURIComponent(url.pathname.slice(11))));
+                        if (request.method === "POST" && url.pathname === "/effects/execute")
+                            return respond(response, 200, await runtime.executeEffect(body));
                         if (request.method === "POST" && url.pathname === "/executions")
                             return respond(response, 200, await runtime.executeCapability(body));
                         if (request.method === "POST" &&
@@ -394,8 +451,11 @@ export async function createExecutionRuntimeProcess(input) {
                         if (request.method === "POST" &&
                             url.pathname === "/observer-signals/list") {
                             const value = object(body ?? {}, "observer signal list input");
+                            const limit = typeof value.limit === "number" ? value.limit : 50;
                             return respond(response, 200, {
-                                signals: runtime.listExecutionObserverSignals(typeof value.limit === "number" ? value.limit : 50),
+                                signals: value.consumer === "task-reconciliation"
+                                    ? observerSignals?.list(limit) ?? []
+                                    : runtime.listExecutionObserverSignals(limit),
                             });
                         }
                         if (request.method === "POST" &&
@@ -449,6 +509,8 @@ export async function createExecutionRuntimeProcess(input) {
         catch (error) {
             state = "STOPPED";
             accepting = false;
+            observerSignals?.close();
+            observerSignals = undefined;
             runtime?.close();
             runtime = undefined;
             throw error;
@@ -464,6 +526,8 @@ export async function createExecutionRuntimeProcess(input) {
         if (running)
             await new Promise((resolveStop, reject) => running.close((error) => (error ? reject(error) : resolveStop())));
         await Promise.allSettled([...active]);
+        observerSignals?.close();
+        observerSignals = undefined;
         runtime?.close();
         runtime = undefined;
         state = "STOPPED";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomflow/proflow-execution-runtime",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -24,11 +24,11 @@
     "SETUP.md"
   ],
   "dependencies": {
-    "@tomflow/proflow-execution-browser-extension": "^0.1.42",
-    "@tomflow/proflow-execution-contracts": "^0.1.10",
-    "@tomflow/proflow-model-contracts": "^0.1.10",
+    "@tomflow/proflow-execution-contracts": "^0.1.12",
+    "@tomflow/proflow-execution-local": "^0.1.16",
     "@tomflow/proflow-module-contract": "^0.1.13",
-    "@tomflow/proflow-execution-local": "^0.1.15"
+    "@tomflow/proflow-model-contracts": "^0.1.10",
+    "@tomflow/proflow-execution-browser-extension": "^0.1.74"
   },
   "devDependencies": {
     "@tomflow/proflow-deployment-conformance": "^0.1.13"

package/proflow.module.json

@@ -3,7 +3,7 @@
 	"contractVersion": "1.0.0",
 	"moduleRef": "execution-runtime",
 	"packageName": "@tomflow/proflow-execution-runtime",
-	"moduleVersion": "0.1.18",
+	"moduleVersion": "0.1.20",
 	"kind": "service",
 	"templateVersion": "1.0.0",
 	"platformCompatibility": ">=1.0.0 <2.0.0",
@@ -18,6 +18,10 @@
 		}
 	],
 	"requires": [
+		{
+			"contractRef": "execution-browser-executor",
+			"versionRange": ">=1.0.0 <2.0.0"
+		},
 		{
 			"contractRef": "execution-local",
 			"versionRange": ">=1.0.0 <2.0.0"