@tomflow/proflow-execution-runtime 0.1.19 → 0.1.20

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @tomflow/proflow-execution-runtime
 
+## 0.1.20
+
+### Patch Changes
+
+- fix(execution-runtime): unify formal effect identity
+
 ## 0.1.19
 
 ### Patch Changes

package/dist/deployment/adapter.d.ts

@@ -6,7 +6,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "execution-runtime";
-            moduleVersion: "0.1.19";
+            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.19";
+            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.19";
+            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.19";
+            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.19";
+            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.19";
+            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.19";
+            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.19";
+            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.19";
+            readonly moduleVersion: "0.1.20";
         } | {
             contract: "deployment.result.v1";
             moduleRef: "execution-runtime";
-            moduleVersion: "0.1.19";
+            moduleVersion: "0.1.20";
             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: "execution-runtime";
     readonly packageName: "@tomflow/proflow-execution-runtime";
-    readonly moduleVersion: "0.1.19";
+    readonly moduleVersion: "0.1.20";
     readonly kind: "service";
     readonly templateVersion: "1.0.0";
     readonly platformCompatibility: ">=1.0.0 <2.0.0";

package/dist/deployment/descriptor.js

@@ -3,7 +3,7 @@ export const descriptor = {
     contractVersion: "1.0.0",
     moduleRef: "execution-runtime",
     packageName: "@tomflow/proflow-execution-runtime",
-    moduleVersion: "0.1.19",
+    moduleVersion: "0.1.20",
     kind: "service",
     templateVersion: "1.0.0",
     platformCompatibility: ">=1.0.0 <2.0.0",

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.js

@@ -441,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" &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomflow/proflow-execution-runtime",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -24,11 +24,11 @@
     "SETUP.md"
   ],
   "dependencies": {
-    "@tomflow/proflow-model-contracts": "^0.1.10",
-    "@tomflow/proflow-execution-browser-extension": "^0.1.51",
-    "@tomflow/proflow-module-contract": "^0.1.13",
+    "@tomflow/proflow-execution-contracts": "^0.1.12",
     "@tomflow/proflow-execution-local": "^0.1.16",
-    "@tomflow/proflow-execution-contracts": "^0.1.11"
+    "@tomflow/proflow-module-contract": "^0.1.13",
+    "@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.19",
+	"moduleVersion": "0.1.20",
 	"kind": "service",
 	"templateVersion": "1.0.0",
 	"platformCompatibility": ">=1.0.0 <2.0.0",