@tomflow/proflow-execution-runtime 0.1.18 → 0.1.19

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @tomflow/proflow-execution-runtime
 
+## 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.19";
             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.19";
         };
         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.19";
             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.19";
             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.19";
             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.19";
             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.19";
             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.19";
         };
         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.19";
         } | {
             contract: "deployment.result.v1";
             moduleRef: "execution-runtime";
-            moduleVersion: "0.1.18";
+            moduleVersion: "0.1.19";
             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.19";
     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.19",
     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/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();
                         }
@@ -394,8 +449,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 +507,8 @@ export async function createExecutionRuntimeProcess(input) {
         catch (error) {
             state = "STOPPED";
             accepting = false;
+            observerSignals?.close();
+            observerSignals = undefined;
             runtime?.close();
             runtime = undefined;
             throw error;
@@ -464,6 +524,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.19",
   "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-browser-extension": "^0.1.51",
     "@tomflow/proflow-module-contract": "^0.1.13",
-    "@tomflow/proflow-execution-local": "^0.1.15"
+    "@tomflow/proflow-execution-local": "^0.1.16",
+    "@tomflow/proflow-execution-contracts": "^0.1.11"
   },
   "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.19",
 	"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"