witnora 0.13.3 → 0.13.4

package/dist/gateway.js

@@ -1,11 +1,12 @@
-import { randomBytes } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { spawn } from "node:child_process";
 import { closeSync, openSync } from "node:fs";
 import { access, chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { loadConnection } from "./credentials.js";
 import { authorizeProjectConnection } from "./device-authorization.js";
+import { inspectIsolatedOutcomeProbe, observeInIsolatedOutcomeProbe } from "./probe-process.js";
 const CONFIG_SCHEMA = "witnora.customer_gateway_setup.v0.1";
 const SECRETS_SCHEMA = "witnora.customer_gateway_local_secrets.v0.1";
 const RUNTIME_SCHEMA = "witnora.managed_gateway_runtime.v0.1";
@@ -132,27 +133,58 @@ export async function doctorCustomerGateway(options) {
         catch (error) {
             checks.push({ id: "hosted_credential", status: "FAIL", message: message(error) });
         }
+        if (config.runtimeWorker) {
+            try {
+                const adapterModulePath = resolve(directory, config.runtimeWorker.adapterModulePath);
+                const probeModulePath = resolve(directory, config.runtimeWorker.probeModulePath);
+                if (adapterModulePath === probeModulePath)
+                    throw new Error("Adapter and outcome probe must use separate modules.");
+                const [adapterDigest, probeDigest] = await Promise.all([
+                    readFile(adapterModulePath).then((bytes) => createHash("sha256").update(bytes).digest("hex")),
+                    readFile(probeModulePath).then((bytes) => createHash("sha256").update(bytes).digest("hex")),
+                ]);
+                if (adapterDigest !== config.runtimeWorker.adapterModuleSha256 || probeDigest !== config.runtimeWorker.probeModuleSha256)
+                    throw new Error("Runtime adapter or probe module digest does not match gateway.json.");
+                const [primary, probe] = await Promise.all([
+                    loadConnection(config.connectionName, { configHome: options.configHome }),
+                    loadConnection(config.runtimeWorker.probeConnectionName, { configHome: options.configHome }),
+                ]);
+                if (!primary || !probe || probe.projectId !== config.projectId || probe.server !== config.server || probe.apiKey === primary.apiKey) {
+                    throw new Error("A separate outcome-probe credential bound to this project is required.");
+                }
+                checks.push({ id: "runtime_configuration", status: "PASS", message: "The digest-pinned adapter module and separate outcome-probe credential are present." });
+            }
+            catch (error) {
+                checks.push({ id: "runtime_configuration", status: "FAIL", message: message(error) });
+            }
+        }
         try {
-            const response = await (options.fetch ?? fetch)(`http://${config.host}:${config.port}/healthz`, { signal: AbortSignal.timeout(800) });
-            if (!response.ok)
-                throw new Error(`Gateway health returned HTTP ${response.status}.`);
+            const health = await gatewayHealth(`http://${config.host}:${config.port}`, options.fetch ?? fetch, Boolean(config.runtimeWorker));
+            if (!health)
+                throw new Error("Gateway health or runtime-worker readiness was not established.");
             checks.push({ id: "process", status: "PASS", message: `Gateway is listening at http://${config.host}:${config.port}.` });
         }
         catch {
             checks.push({ id: "process", status: "WARN", message: "Gateway is not running yet. Start managed mode with `witnora gateway start`." });
         }
     }
+    const runtimeConfigurationReady = checks.some((check) => check.id === "runtime_configuration" && check.status === "PASS")
+        && checks.some((check) => check.id === "process" && check.status === "PASS");
     if (config && secrets) {
-        checks.push({ id: "enforcement", status: "WARN", message: "Write-credential mediation is not configured; current evidence ceiling is RECORDED." });
-        checks.push({ id: "outcome_probe", status: "WARN", message: "An independent read-only outcome probe is not configured." });
+        checks.push(config.runtimeWorker && runtimeConfigurationReady
+            ? { id: "enforcement", status: "PASS", message: `Exact adapter ${config.runtimeWorker.adapterId}@${config.runtimeWorker.adapterVersion} is configured behind the durable worker.` }
+            : { id: "enforcement", status: "WARN", message: "Exact write-credential mediation is not proven ready; current evidence ceiling remains RECORDED." });
+        checks.push(config.runtimeWorker && runtimeConfigurationReady
+            ? { id: "outcome_probe", status: "PASS", message: `Separate read-only probe ${config.runtimeWorker.probeId} is configured.` }
+            : { id: "outcome_probe", status: "WARN", message: "An independent digest-pinned probe and read-only target credential are not proven ready." });
     }
     const failed = checks.some((check) => check.status === "FAIL");
     return {
         schemaVersion: "witnora.customer_gateway_doctor.v0.1",
-        overall: failed ? "SETUP_INCOMPLETE" : "READY_TO_RECORD",
+        overall: failed ? "SETUP_INCOMPLETE" : runtimeConfigurationReady ? "READY_FOR_RUNTIME" : "READY_TO_RECORD",
         checks,
-        evidenceCeiling: "recorded",
-        nextAction: failed ? "Run `witnora gateway init --project <project-id>` again after resolving failed checks." : "Ensure the managed Gateway is healthy, then send one sandbox run through its local event API.",
+        evidenceCeiling: runtimeConfigurationReady ? "outcome_verified" : "recorded",
+        nextAction: failed ? "Resolve the failed Gateway checks before sending another action." : runtimeConfigurationReady ? "Run the Agent normally; approved configured actions continue automatically after the human decision." : "Ensure the managed Gateway is healthy, then send one sandbox run through its local event API.",
     };
 }
 export async function runCustomerGateway(options) {
@@ -161,6 +193,7 @@ export async function runCustomerGateway(options) {
     const CustomerSourceKeyRing = remoteCollector.CustomerSourceKeyRing;
     const RemoteCollectorClient = remoteCollector.RemoteCollectorClient;
     const startCustomerOwnedCollectorGateway = collectorGateway.startCustomerOwnedCollectorGateway;
+    const durableWorker = configRuntimeWorkerImport();
     const directory = resolve(options.repository ?? process.cwd(), options.dir ?? ".witnora/gateway");
     const config = parseConfig(await readFile(join(directory, "gateway.json"), "utf8"));
     const secrets = parseSecrets(await readFile(join(directory, "secrets.json"), "utf8"));
@@ -173,6 +206,14 @@ export async function runCustomerGateway(options) {
     const keyRing = await (await exists(keyRingPath)
         ? CustomerSourceKeyRing.open(keyRingPath)
         : CustomerSourceKeyRing.create(keyRingPath, config.collectorId));
+    const actionWorker = config.runtimeWorker
+        ? await createConfiguredRuntimeActionWorker({
+            directory, config, connection, configHome: options.configHome,
+            DurableApprovedActionWorker: (await durableWorker).DurableApprovedActionWorker,
+            FileActionCheckpointStore: (await durableWorker).FileActionCheckpointStore,
+        })
+        : undefined;
+    actionWorker?.start();
     const gateway = await startCustomerOwnedCollectorGateway({
         client: new RemoteCollectorClient({ baseUrl: connection.server, projectId: connection.projectId, apiKey: connection.apiKey }),
         keyRing,
@@ -181,13 +222,143 @@ export async function runCustomerGateway(options) {
         host: process.env.WITNORA_GATEWAY_HOST?.trim() || config.host,
         port: gatewayPort(process.env.WITNORA_GATEWAY_PORT, config.port),
         environment: "customer-owned",
+        ...(actionWorker && config.runtimeWorker ? { actionWorker: {
+                track: (input) => isConfiguredRuntimeProposal(input.proposal, config.runtimeWorker) ? actionWorker.track(input) : Promise.resolve(undefined),
+                status: () => actionWorker.status(), close: () => actionWorker.stop(),
+            } } : {}),
     });
     process.stdout.write(`Witnora customer-owned Gateway listening on ${gateway.baseUrl}\n`);
-    process.stdout.write("Evidence ceiling: RECORDED. No target write credential or outcome-probe credential is loaded by this reference process.\n");
+    process.stdout.write(config.runtimeWorker
+        ? "Runtime worker: READY. Approved exact configured actions execute automatically, then use the separate read-only probe and Hosted signed receipt.\n"
+        : "Evidence ceiling: RECORDED. No exact target adapter and separate outcome probe are configured, so runtime writes remain fail-closed.\n");
     for (const signal of ["SIGINT", "SIGTERM"]) {
         process.once(signal, () => void gateway.close().finally(() => process.exit(0)));
     }
 }
+export async function createConfiguredRuntimeActionWorker(input) {
+    const workerConfig = input.config.runtimeWorker;
+    if (!workerConfig?.enabled)
+        throw new Error("Runtime worker is not enabled.");
+    const adapterModulePath = resolve(input.directory, workerConfig.adapterModulePath);
+    const probeModulePath = resolve(input.directory, workerConfig.probeModulePath);
+    if (adapterModulePath === probeModulePath)
+        throw new Error("Adapter and outcome probe must use separate modules.");
+    const [adapterBytes, probeBytes] = await Promise.all([readFile(adapterModulePath), readFile(probeModulePath)]);
+    const adapterModuleDigest = createHash("sha256").update(adapterBytes).digest("hex");
+    const probeModuleDigest = createHash("sha256").update(probeBytes).digest("hex");
+    if (adapterModuleDigest !== workerConfig.adapterModuleSha256 || probeModuleDigest !== workerConfig.probeModuleSha256)
+        throw new Error("Runtime adapter or probe module digest does not match gateway.json; refusing to load it.");
+    const adapterModule = await import(`${pathToFileURL(adapterModulePath).href}?sha256=${adapterModuleDigest}`);
+    if (typeof adapterModule.createWitnoraRuntimeAdapter !== "function")
+        throw new Error("Runtime adapter module must export its factory.");
+    const probeConnection = await loadConnection(workerConfig.probeConnectionName, { configHome: input.configHome });
+    if (!probeConnection || probeConnection.projectId !== input.config.projectId || probeConnection.server !== input.config.server) {
+        throw new Error("The separate outcome-probe credential does not match this Gateway project and server.");
+    }
+    if (probeConnection.apiKey === input.connection.apiKey)
+        throw new Error("The execution Gateway and outcome probe must use separate Hosted credentials.");
+    const adapterContext = Object.freeze({
+        adapterId: workerConfig.adapterId, adapterVersion: workerConfig.adapterVersion,
+        projectId: input.config.projectId,
+        hosted: runtimeHostedTransport(input.connection, input.fetch ?? fetch),
+        storageDirectory: resolve(input.directory, "data", "runtime-actions"),
+    });
+    const isolatedProbeConfig = {
+        modulePath: probeModulePath,
+        moduleSha256: probeModuleDigest,
+        probeId: workerConfig.probeId,
+        projectId: input.config.projectId,
+        credentialHandle: workerConfig.probeTargetCredentialHandle,
+    };
+    const runtime = await adapterModule.createWitnoraRuntimeAdapter(adapterContext);
+    await inspectIsolatedOutcomeProbe(isolatedProbeConfig);
+    if (runtime.id !== workerConfig.adapterId || runtime.version !== workerConfig.adapterVersion || runtime.reconcileReadOnly !== true
+        || typeof runtime.prepareClaim !== "function" || typeof runtime.execute !== "function" || typeof runtime.reconcile !== "function") {
+        throw new Error("Runtime adapter does not match the exact configured id/version or read-only reconciliation contract.");
+    }
+    const requestFetch = input.fetch ?? fetch;
+    const primary = projectTransport(input.connection, requestFetch);
+    const verifier = projectTransport(probeConnection, requestFetch);
+    return new input.DurableApprovedActionWorker({
+        config: {
+            adapterId: workerConfig.adapterId, adapterVersion: workerConfig.adapterVersion, probeId: workerConfig.probeId,
+            probeCredentialHandle: workerConfig.probeTargetCredentialHandle,
+            runtimeIdentityId: workerConfig.runtimeIdentityId, grantTtlSeconds: workerConfig.grantTtlSeconds, pollIntervalMs: workerConfig.pollIntervalMs,
+        },
+        store: new input.FileActionCheckpointStore(resolve(input.directory, "data", "runtime-actions", "checkpoints")),
+        hosted: {
+            getAction: (actionId) => primary(`actions/${encodeURIComponent(actionId)}`),
+            issueExecutionGrant: (actionId, body, idempotencyKey) => primary(`actions/${encodeURIComponent(actionId)}/execution-grant`, { method: "POST", body, idempotencyKey }),
+            verifyAction: (actionId, body, idempotencyKey) => verifier(`actions/${encodeURIComponent(actionId)}/verify`, { method: "POST", body, idempotencyKey }),
+            listActionReceipts: async (actionId) => (await primary(`actions/${encodeURIComponent(actionId)}/receipts`)).receipts ?? [],
+            claimExecutionGrant: (executionGrantId, claim, idempotencyKey) => claimHostedExecutionGrant(input.connection, requestFetch, executionGrantId, claim, idempotencyKey),
+        },
+        runtime: { reconcileReadOnly: true, prepareClaim: runtime.prepareClaim, execute: runtime.execute, reconcile: runtime.reconcile },
+        probe: {
+            id: workerConfig.probeId,
+            credentialHandle: workerConfig.probeTargetCredentialHandle,
+            readOnly: true,
+            observe: (request) => observeInIsolatedOutcomeProbe(isolatedProbeConfig, request),
+        },
+    });
+}
+function projectTransport(connection, requestFetch) {
+    return async (suffix, options = {}) => {
+        const response = await requestFetch(`${connection.server}/v1/projects/${encodeURIComponent(connection.projectId)}/${suffix}`, {
+            method: options.method ?? "GET",
+            headers: { authorization: `Bearer ${connection.apiKey}`, ...(options.body ? { "content-type": "application/json" } : {}), ...(options.idempotencyKey ? { "idempotency-key": options.idempotencyKey } : {}) },
+            ...(options.body ? { body: JSON.stringify(options.body) } : {}),
+        });
+        const body = await response.json().catch(() => ({}));
+        if (!response.ok)
+            throw new Error(String(body.error ?? `Witnora Hosted API returned HTTP ${response.status}.`));
+        return body;
+    };
+}
+function runtimeHostedTransport(connection, requestFetch) {
+    return {
+        baseUrl: connection.server,
+        projectId: connection.projectId,
+        async request(suffix, options = {}) {
+            if (!/^(execution-grants\/[A-Za-z0-9._:-]+\/consume|execution-attempts\/[A-Za-z0-9._:-]+\/phase|execution-sessions\/[A-Za-z0-9._:-]+\/evidence)$/.test(suffix)) {
+                throw new Error("Runtime adapter attempted to access a Hosted path outside its execution boundary.");
+            }
+            if ((options.method ?? "GET") !== "POST")
+                throw new Error("Runtime Hosted execution paths require POST.");
+            const response = await requestFetch(`${connection.server}/v1/runtime/projects/${encodeURIComponent(connection.projectId)}/${suffix}`, {
+                method: "POST",
+                headers: { authorization: `Bearer ${connection.apiKey}`, ...(options.body ? { "content-type": "application/json" } : {}), ...(options.idempotencyKey ? { "idempotency-key": options.idempotencyKey } : {}) },
+                ...(options.body ? { body: JSON.stringify(options.body) } : {}),
+            });
+            const body = await response.json().catch(() => ({}));
+            if (!response.ok)
+                throw new Error(String(body.error ?? `Witnora Hosted runtime API returned HTTP ${response.status}.`));
+            return body;
+        },
+    };
+}
+async function claimHostedExecutionGrant(connection, requestFetch, executionGrantId, claim, idempotencyKey) {
+    const response = await requestFetch(`${connection.server}/v1/runtime/projects/${encodeURIComponent(connection.projectId)}/execution-grants/${encodeURIComponent(executionGrantId)}/claim`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${connection.apiKey}`, "content-type": "application/json", "idempotency-key": idempotencyKey },
+        body: JSON.stringify(claim),
+    });
+    if (response.status === 409)
+        return { acquired: false };
+    const body = await response.json().catch(() => ({}));
+    if (!response.ok)
+        throw new Error(String(body.error ?? `Witnora Hosted grant claim returned HTTP ${response.status}.`));
+    return { acquired: body.status === "CLAIMED" };
+}
+function configRuntimeWorkerImport() {
+    return import(new URL("./internal/control-client/durable-action-worker.js", import.meta.url).href);
+}
+function isConfiguredRuntimeProposal(proposal, config) {
+    const intent = proposal.executionIntent;
+    return Boolean(intent && typeof intent === "object" && !Array.isArray(intent)
+        && intent.adapterId === config.adapterId
+        && typeof intent.adapterVersionConstraint === "string");
+}
 export async function startManagedCustomerGateway(options = {}) {
     const repository = resolve(options.repository ?? process.cwd());
     const directory = resolve(repository, options.dir ?? ".witnora/gateway");
@@ -272,7 +443,7 @@ export async function statusManagedCustomerGateway(options = {}) {
     const config = parseConfig(await readFile(join(directory, "gateway.json"), "utf8"));
     const baseUrl = `http://${config.host}:${config.port}`;
     const runtime = await readRuntime(directory);
-    const health = await gatewayHealth(baseUrl, options.fetch ?? fetch);
+    const health = await gatewayHealth(baseUrl, options.fetch ?? fetch, Boolean(config.runtimeWorker));
     const base = {
         schemaVersion: "witnora.managed_gateway_status.v0.1",
         baseUrl,
@@ -387,8 +558,30 @@ function parseConfig(raw) {
         throw new Error("Gateway privacyMode must remain metadata_only.");
     if (!value.host || !Number.isSafeInteger(value.port) || Number(value.port) < 1 || Number(value.port) > 65_535)
         throw new Error("Gateway host and port are invalid.");
+    if (value.runtimeWorker)
+        validateRuntimeWorkerConfig(value.runtimeWorker);
     return value;
 }
+function validateRuntimeWorkerConfig(value) {
+    if (value.enabled !== true || !value.adapterModulePath || !/^[a-f0-9]{64}$/.test(value.adapterModuleSha256)
+        || !value.probeModulePath || !/^[a-f0-9]{64}$/.test(value.probeModuleSha256)
+        || !value.adapterId || !/^v?\d+\.\d+\.\d+$/.test(value.adapterVersion) || !value.probeId
+        || !value.probeConnectionName || !credentialHandle(value.probeTargetCredentialHandle) || !value.runtimeIdentityId) {
+        throw new Error("gateway.json runtimeWorker requires separate exact adapter/probe module digests, adapter id/version, probe credentials, and runtime identity.");
+    }
+    if (value.adapterModulePath === value.probeModulePath || value.adapterModuleSha256 === value.probeModuleSha256)
+        throw new Error("runtimeWorker adapter and outcome probe modules must be independently pinned.");
+    if (value.adapterId === value.probeId)
+        throw new Error("runtimeWorker adapter and outcome probe must be separate.");
+    if (value.grantTtlSeconds !== undefined && (!Number.isInteger(value.grantTtlSeconds) || value.grantTtlSeconds < 15 || value.grantTtlSeconds > 300))
+        throw new Error("runtimeWorker grantTtlSeconds must be between 15 and 300.");
+    if (value.pollIntervalMs !== undefined && (!Number.isInteger(value.pollIntervalMs) || value.pollIntervalMs < 250 || value.pollIntervalMs > 30_000))
+        throw new Error("runtimeWorker pollIntervalMs must be between 250 and 30000.");
+}
+function credentialHandle(value) {
+    return typeof value === "string" && value.length <= 256 && /^[a-z][a-z0-9+.-]*:\/\/[^\s]+$/i.test(value)
+        && !/(?:ac_live_|bearer\s|private.?key|password|token=)/i.test(value);
+}
 function parseSecrets(raw) {
     const value = JSON.parse(raw);
     if (value.schemaVersion !== SECRETS_SCHEMA || typeof value.gatewayToken !== "string" || value.gatewayToken.length < 32) {
@@ -443,12 +636,14 @@ function gatewayPaths(directory) {
         join(directory, "README.md"),
     ];
 }
-async function gatewayHealth(baseUrl, requestFetch) {
+async function gatewayHealth(baseUrl, requestFetch, requireRuntimeWorker = false) {
     try {
         const response = await requestFetch(`${baseUrl}/healthz`, { signal: AbortSignal.timeout(800) });
         if (!response.ok)
             return undefined;
         const value = await response.json();
+        if (requireRuntimeWorker && value.actionWorker?.ready !== true)
+            return undefined;
         return typeof value.collectorId === "string" && value.collectorId ? { collectorId: value.collectorId } : undefined;
     }
     catch {

package/dist/internal/control-client/collector-gateway.d.ts

@@ -30,6 +30,14 @@ export interface CustomerOwnedCollectorGatewayOptions {
     flushIntervalMs?: number;
     heartbeatIntervalMs?: number;
     maxBodyBytes?: number;
+    actionWorker?: {
+        track(input: {
+            actionId: string;
+            proposal: Record<string, unknown>;
+        }): Promise<unknown>;
+        status(): Promise<Record<string, unknown>>;
+        close?(): void | Promise<void>;
+    };
 }
 export interface CustomerOwnedCollectorGateway {
     baseUrl: string;
@@ -50,6 +58,7 @@ export interface CollectorGatewayStatus {
     lastAckSequence?: number;
     lastRemoteSuccessAt?: string;
     lastRemoteError?: string;
+    actionWorker?: Record<string, unknown>;
 }
 export declare function startCustomerOwnedCollectorGateway(options: CustomerOwnedCollectorGatewayOptions): Promise<CustomerOwnedCollectorGateway>;
 //# sourceMappingURL=collector-gateway.d.ts.map

package/dist/internal/control-client/collector-gateway.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collector-gateway.d.ts","sourceRoot":"","sources":["../../../../agentcert-sdk/src/collector-gateway.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,qBAAqB,EAGrB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC/B,MAAM,uBAAuB,CAAC;AAE/B,MAAM,WAAW,wBAAwB;IACvC,iBAAiB,CAAC,KAAK,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACjJ,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,yBAAyB,EAAE,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAClH,SAAS,CAAC,KAAK,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,oBAAoB,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QAAC,eAAe,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAChK,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC7F,aAAa,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC3G,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC9D,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACjI;AAED,MAAM,WAAW,oCAAoC;IACnD,MAAM,EAAE,wBAAwB,CAAC;IACjC,OAAO,EAAE,qBAAqB,CAAC;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,6BAA6B;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,KAAK,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7E,MAAM,IAAI,OAAO,CAAC,sBAAsB,CAAC,CAAC;CAC3C;AAED,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,kDAAkD,CAAC;IAClE,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAUD,wBAAsB,kCAAkC,CAAC,OAAO,EAAE,oCAAoC,GAAG,OAAO,CAAC,6BAA6B,CAAC,CAqL9I"}
+{"version":3,"file":"collector-gateway.d.ts","sourceRoot":"","sources":["../../../../agentcert-sdk/src/collector-gateway.ts"],"names":[],"mappings":"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"}

package/dist/internal/control-client/collector-gateway.js

@@ -84,6 +84,7 @@ export async function startCustomerOwnedCollectorGateway(options) {
             lastAckSequence,
             lastRemoteSuccessAt,
             lastRemoteError,
+            ...(options.actionWorker ? { actionWorker: await options.actionWorker.status() } : {}),
         };
     };
     const server = createServer(async (request, response) => {
@@ -96,7 +97,11 @@ export async function startCustomerOwnedCollectorGateway(options) {
                 return json(response, 200, await flush());
             if (request.method === "POST" && url.pathname === "/v1/actions") {
                 const body = await readJson(request, options.maxBodyBytes ?? 1_048_576);
-                return json(response, 202, await options.client.proposeAction(object(body.proposal), identifier(body.idempotencyKey, "idempotencyKey")));
+                const proposal = object(body.proposal);
+                const action = await options.client.proposeAction(proposal, identifier(body.idempotencyKey, "idempotencyKey"));
+                if (options.actionWorker)
+                    await options.actionWorker.track({ actionId: identifier(action.id, "actionId"), proposal });
+                return json(response, 202, action);
             }
             const actionRoute = url.pathname.match(/^\/v1\/actions\/([A-Za-z0-9._:-]+)$/);
             if (request.method === "GET" && actionRoute) {
@@ -187,6 +192,7 @@ export async function startCustomerOwnedCollectorGateway(options) {
         close: async () => {
             clearInterval(flushTimer);
             clearInterval(heartbeatTimer);
+            await options.actionWorker?.close?.();
             await flush();
             await close(server);
         },

package/dist/internal/control-client/durable-action-worker.d.ts

@@ -0,0 +1,194 @@
+export type DurableActionPhase = "TRACKED" | "WAITING_APPROVAL" | "DENIED" | "EXPIRED" | "BLOCKED" | "GRANT_ISSUED" | "EXECUTION_STARTED" | "UNKNOWN_RESULT" | "EXECUTED" | "PROBED" | "COMPLETED";
+export interface DurableWorkerProposal {
+    externalId: string;
+    actionType: string;
+    targetSystem: string;
+    expectedState?: Record<string, unknown>;
+    executionIntent: {
+        adapterId: string;
+        adapterVersionConstraint: string;
+        allowedOrigins: string[];
+        allowedOperation: string;
+        allowedResource: string;
+        approvedParameters: Record<string, unknown>;
+        outcomePredicate: Record<string, unknown>;
+        agentBuildId: string;
+        agentBuildDigest: string;
+    };
+    [key: string]: unknown;
+}
+export interface DurableWorkerAction {
+    id: string;
+    externalId: string;
+    status: "PENDING_APPROVAL" | "APPROVED" | "ALLOWED" | "REJECTED" | "DENIED" | "APPROVAL_EXPIRED" | "GRANT_EXPIRED" | "VERIFIED" | string;
+    actionType: string;
+    targetSystem: string;
+    expectedState?: Record<string, unknown>;
+    approvalExpiresAt?: string;
+    assuranceContext?: {
+        executionIntent?: {
+            adapterId: string;
+            adapterVersionConstraint: string;
+            allowedOrigins: string[];
+            allowedOperation: string;
+            allowedResource: string;
+            approvedParametersDigest: string;
+            outcomePredicateDigest: string;
+            agentBuildId: string;
+            agentBuildDigest: string;
+        };
+    };
+    [key: string]: unknown;
+}
+export interface DurableWorkerGrant {
+    id: string;
+    status: string;
+    grant: {
+        payload?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export interface DurableWorkerExecutionResult {
+    executionSessionId: string;
+    [key: string]: unknown;
+}
+export interface DurableWorkerHostedReservation {
+    executionSessionId: string;
+    claim: Record<string, unknown>;
+}
+export interface DurableWorkerObservation {
+    observedState: Record<string, unknown>;
+    observationMethod: "TARGET_API" | "TARGET_UI" | "TARGET_AUDIT_LOG" | "WEBHOOK" | "DATABASE_QUERY" | "THIRD_PARTY_CONFIRMATION";
+    observationSource: string;
+    evidenceReferences?: string[];
+    confidence?: number;
+}
+export interface DurableActionCheckpoint {
+    schemaVersion: "witnora.durable_action_checkpoint.v0.1";
+    actionId: string;
+    phase: DurableActionPhase;
+    proposal: DurableWorkerProposal;
+    proposalSha256: string;
+    grant?: DurableWorkerGrant;
+    execution?: DurableWorkerExecutionResult;
+    observation?: DurableWorkerObservation;
+    receiptId?: string;
+    executionClaimId?: string;
+    hostedReservation?: DurableWorkerHostedReservation;
+    limitation?: string;
+    updatedAt: string;
+}
+export interface ActionCheckpointStore {
+    load(actionId: string): Promise<DurableActionCheckpoint | undefined>;
+    save(checkpoint: DurableActionCheckpoint): Promise<void>;
+    list(): Promise<DurableActionCheckpoint[]>;
+    claimExecution(actionId: string, ownerId: string, claimedAt: string): Promise<{
+        acquired: boolean;
+        claimId: string;
+    }>;
+}
+export declare class FileActionCheckpointStore implements ActionCheckpointStore {
+    private readonly directory;
+    constructor(directory: string);
+    load(actionId: string): Promise<DurableActionCheckpoint | undefined>;
+    save(checkpoint: DurableActionCheckpoint): Promise<void>;
+    list(): Promise<DurableActionCheckpoint[]>;
+    claimExecution(actionId: string, ownerId: string, claimedAt: string): Promise<{
+        acquired: boolean;
+        claimId: string;
+    }>;
+    private path;
+    private claimPath;
+}
+export interface DurableApprovedActionWorkerOptions {
+    config: {
+        adapterId: string;
+        adapterVersion: string;
+        probeId: string;
+        probeCredentialHandle: string;
+        runtimeIdentityId: string;
+        grantTtlSeconds?: number;
+        pollIntervalMs?: number;
+    };
+    store: ActionCheckpointStore;
+    hosted: {
+        getAction(actionId: string): Promise<DurableWorkerAction>;
+        issueExecutionGrant(actionId: string, input: Record<string, unknown>, idempotencyKey: string): Promise<DurableWorkerGrant>;
+        verifyAction(actionId: string, input: Record<string, unknown>, idempotencyKey: string): Promise<{
+            status: string;
+            verificationSuccess?: boolean;
+        }>;
+        listActionReceipts(actionId: string): Promise<Array<{
+            id: string;
+            receipt?: {
+                signatureSet?: unknown[];
+            };
+        }>>;
+        claimExecutionGrant(executionGrantId: string, claim: Record<string, unknown>, idempotencyKey: string): Promise<{
+            acquired: boolean;
+        }>;
+    };
+    runtime: {
+        reconcileReadOnly: true;
+        prepareClaim(input: {
+            action: DurableWorkerAction;
+            proposal: DurableWorkerProposal;
+            grant: DurableWorkerGrant;
+        }): Promise<DurableWorkerHostedReservation>;
+        execute(input: {
+            action: DurableWorkerAction;
+            proposal: DurableWorkerProposal;
+            grant: DurableWorkerGrant;
+            hostedReservation: DurableWorkerHostedReservation;
+        }): Promise<DurableWorkerExecutionResult>;
+        reconcile(input: {
+            action: DurableWorkerAction;
+            proposal: DurableWorkerProposal;
+            grant: DurableWorkerGrant;
+        }): Promise<DurableWorkerExecutionResult | undefined>;
+    };
+    probe: {
+        id: string;
+        credentialHandle: string;
+        readOnly: true;
+        observe(input: {
+            action: DurableWorkerAction;
+            proposal: DurableWorkerProposal;
+            grant: DurableWorkerGrant;
+            execution: DurableWorkerExecutionResult;
+        }): Promise<DurableWorkerObservation>;
+    };
+    now?: () => Date;
+}
+export interface DurableActionWorkerStatus {
+    schemaVersion: "witnora.durable_action_worker_status.v0.1";
+    ready: boolean;
+    trackedActionCount: number;
+    pendingActionCount: number;
+    unknownResultCount: number;
+    lastHeartbeatAt: string;
+    lastError?: string;
+}
+export declare class DurableApprovedActionWorker {
+    private readonly options;
+    private readonly now;
+    private readonly chains;
+    private timer?;
+    private lastHeartbeatAt;
+    private lastError?;
+    private readonly workerId;
+    constructor(options: DurableApprovedActionWorkerOptions);
+    track(input: {
+        actionId: string;
+        proposal: DurableWorkerProposal;
+    }): Promise<DurableActionCheckpoint>;
+    tick(actionId: string): Promise<DurableActionCheckpoint>;
+    start(): void;
+    stop(): void;
+    status(): Promise<DurableActionWorkerStatus>;
+    private tickOnce;
+    private persist;
+}
+export declare function runtimeAdapterVersionSatisfies(version: string, constraint: string): boolean;
+//# sourceMappingURL=durable-action-worker.d.ts.map

package/dist/internal/control-client/durable-action-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable-action-worker.d.ts","sourceRoot":"","sources":["../../../../agentcert-sdk/src/durable-action-worker.ts"],"names":[],"mappings":"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"}

package/dist/internal/control-client/durable-action-worker.js

@@ -0,0 +1,359 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, open, readFile, readdir, rename } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { canonicalJson } from "./canonical.js";
+export class FileActionCheckpointStore {
+    directory;
+    constructor(directory) { this.directory = resolve(directory); }
+    async load(actionId) {
+        try {
+            return parseCheckpoint(await readFile(this.path(actionId), "utf8"));
+        }
+        catch (error) {
+            if (isMissing(error))
+                return undefined;
+            throw error;
+        }
+    }
+    async save(checkpoint) {
+        const path = this.path(checkpoint.actionId);
+        await mkdir(dirname(path), { recursive: true });
+        const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+        const handle = await open(temporary, "w", 0o600);
+        try {
+            await handle.writeFile(`${JSON.stringify(checkpoint, null, 2)}\n`, "utf8");
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await rename(temporary, path);
+    }
+    async list() {
+        let names;
+        try {
+            names = await readdir(this.directory);
+        }
+        catch (error) {
+            if (isMissing(error))
+                return [];
+            throw error;
+        }
+        const values = await Promise.all(names.filter((name) => name.endsWith(".json")).map(async (name) => parseCheckpoint(await readFile(join(this.directory, name), "utf8"))));
+        return values.sort((left, right) => left.updatedAt.localeCompare(right.updatedAt));
+    }
+    async claimExecution(actionId, ownerId, claimedAt) {
+        const path = this.claimPath(actionId);
+        await mkdir(dirname(path), { recursive: true });
+        const claimId = randomUUID();
+        try {
+            const handle = await open(path, "wx", 0o600);
+            try {
+                await handle.writeFile(`${JSON.stringify({ schemaVersion: "witnora.execution_claim.v0.1", actionId, claimId, ownerId, claimedAt })}\n`, "utf8");
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            return { acquired: true, claimId };
+        }
+        catch (error) {
+            if (!isAlreadyExists(error))
+                throw error;
+            const existing = JSON.parse(await readFile(path, "utf8"));
+            if (typeof existing.claimId !== "string" || !existing.claimId)
+                throw new Error("Existing execution claim is invalid; refusing to dispatch.");
+            return { acquired: false, claimId: existing.claimId };
+        }
+    }
+    path(actionId) {
+        if (!/^[A-Za-z0-9._:-]+$/.test(actionId))
+            throw new Error("actionId contains unsupported characters.");
+        return join(this.directory, `${actionId}.json`);
+    }
+    claimPath(actionId) {
+        if (!/^[A-Za-z0-9._:-]+$/.test(actionId))
+            throw new Error("actionId contains unsupported characters.");
+        return join(this.directory, `${actionId}.execution-claim`);
+    }
+}
+export class DurableApprovedActionWorker {
+    options;
+    now;
+    chains = new Map();
+    timer;
+    lastHeartbeatAt;
+    lastError;
+    workerId = randomUUID();
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? (() => new Date());
+        if (!options.config.adapterId || !validVersion(options.config.adapterVersion))
+            throw new Error("An exact adapter id and semantic version are required.");
+        if (!options.config.probeId || !options.config.probeCredentialHandle || options.probe.id !== options.config.probeId
+            || options.probe.credentialHandle !== options.config.probeCredentialHandle || options.probe.readOnly !== true)
+            throw new Error("An exact separate read-only probe credential is required.");
+        if (options.config.adapterId === options.config.probeId)
+            throw new Error("The adapter and outcome probe must be separate.");
+        if (options.runtime.reconcileReadOnly !== true)
+            throw new Error("Unknown writes require an explicitly read-only reconciliation path.");
+        this.lastHeartbeatAt = this.now().toISOString();
+    }
+    async track(input) {
+        assertProposal(input.proposal);
+        const existing = await this.options.store.load(input.actionId);
+        const digest = sha256(input.proposal);
+        if (existing) {
+            if (existing.proposalSha256 !== digest)
+                throw new Error("Action id was already tracked with a different proposal.");
+            return existing;
+        }
+        const checkpoint = {
+            schemaVersion: "witnora.durable_action_checkpoint.v0.1", actionId: input.actionId, phase: "TRACKED",
+            proposal: structuredClone(input.proposal), proposalSha256: digest, updatedAt: this.now().toISOString(),
+        };
+        await this.options.store.save(checkpoint);
+        return checkpoint;
+    }
+    tick(actionId) {
+        const previous = this.chains.get(actionId) ?? Promise.resolve(undefined);
+        const next = previous.catch(() => undefined).then(() => this.tickOnce(actionId));
+        this.chains.set(actionId, next);
+        return next.finally(() => { if (this.chains.get(actionId) === next)
+            this.chains.delete(actionId); });
+    }
+    start() {
+        if (this.timer)
+            return;
+        const poll = async () => {
+            this.lastHeartbeatAt = this.now().toISOString();
+            const checkpoints = await this.options.store.list();
+            let cycleError;
+            await Promise.all(checkpoints.filter((item) => !terminal(item.phase)).map((item) => this.tick(item.actionId).catch((error) => { cycleError = message(error); })));
+            this.lastError = cycleError;
+        };
+        void poll().catch((error) => { this.lastError = message(error); });
+        this.timer = setInterval(() => void poll().catch((error) => { this.lastError = message(error); }), this.options.config.pollIntervalMs ?? 2_000);
+        this.timer.unref();
+    }
+    stop() { if (this.timer)
+        clearInterval(this.timer); this.timer = undefined; }
+    async status() {
+        const checkpoints = await this.options.store.list();
+        return {
+            schemaVersion: "witnora.durable_action_worker_status.v0.1",
+            ready: Boolean(this.timer) && !this.lastError,
+            trackedActionCount: checkpoints.length,
+            pendingActionCount: checkpoints.filter((item) => !terminal(item.phase)).length,
+            unknownResultCount: checkpoints.filter((item) => item.phase === "UNKNOWN_RESULT").length,
+            lastHeartbeatAt: this.lastHeartbeatAt,
+            ...(this.lastError ? { lastError: this.lastError } : {}),
+        };
+    }
+    async tickOnce(actionId) {
+        let checkpoint = await this.options.store.load(actionId);
+        if (!checkpoint)
+            throw new Error(`Action ${actionId} is not tracked.`);
+        if (terminal(checkpoint.phase))
+            return checkpoint;
+        const action = await this.options.hosted.getAction(actionId);
+        if (!exactActionMatches(action, actionId, checkpoint.proposal, this.options.config.adapterId, this.options.config.adapterVersion)) {
+            return this.persist(checkpoint, "BLOCKED", { limitation: "Hosted action no longer matches the exact locally configured action, adapter, or build binding." });
+        }
+        if ((checkpoint.phase === "EXECUTION_STARTED" || checkpoint.phase === "UNKNOWN_RESULT") && checkpoint.grant) {
+            if (!exactGrantMatches(checkpoint.grant, actionId, checkpoint.proposal, this.options.config.runtimeIdentityId)) {
+                return this.persist(checkpoint, "BLOCKED", { limitation: "Hosted grant does not match the exact approved local action binding." });
+            }
+            const reconciled = await this.options.runtime.reconcile({ action, proposal: checkpoint.proposal, grant: checkpoint.grant });
+            if (!reconciled)
+                return this.persist(checkpoint, "UNKNOWN_RESULT", { limitation: "Write result is unknown. The worker will only use read-only reconciliation and will never redispatch this grant." });
+            checkpoint = await this.persist(checkpoint, "EXECUTED", { execution: reconciled, limitation: undefined });
+        }
+        if (!checkpoint.execution) {
+            if (action.status === "REJECTED" || action.status === "DENIED")
+                return this.persist(checkpoint, "DENIED");
+            if (action.status === "APPROVAL_EXPIRED" || action.status === "GRANT_EXPIRED" || (action.status === "APPROVED" && expired(action.approvalExpiresAt, this.now())))
+                return this.persist(checkpoint, "EXPIRED");
+            if (action.status === "PENDING_APPROVAL")
+                return this.persist(checkpoint, "WAITING_APPROVAL");
+            if (action.status !== "APPROVED" && action.status !== "ALLOWED") {
+                return this.persist(checkpoint, "BLOCKED", { limitation: `Action status ${action.status} is not executable.` });
+            }
+        }
+        if (!checkpoint.grant && !checkpoint.execution) {
+            const intent = checkpoint.proposal.executionIntent;
+            const grant = await this.options.hosted.issueExecutionGrant(actionId, {
+                runtimeIdentityId: this.options.config.runtimeIdentityId,
+                adapterId: intent.adapterId,
+                adapterVersionConstraint: intent.adapterVersionConstraint,
+                allowedOrigins: intent.allowedOrigins,
+                allowedOperation: intent.allowedOperation,
+                allowedResource: intent.allowedResource,
+                approvedParameters: intent.approvedParameters,
+                outcomePredicate: intent.outcomePredicate,
+                agentBuildId: intent.agentBuildId,
+                agentBuildDigest: intent.agentBuildDigest,
+                ttlSeconds: this.options.config.grantTtlSeconds ?? 120,
+            }, `durable-worker:grant:${actionId}`);
+            checkpoint = await this.persist(checkpoint, "GRANT_ISSUED", { grant });
+        }
+        const grant = checkpoint.grant;
+        if (!grant)
+            return this.persist(checkpoint, "BLOCKED", { limitation: "A durable execution result exists without its bound Hosted grant." });
+        const grantPayload = grant.grant.payload ?? {};
+        if (!exactGrantMatches(grant, actionId, checkpoint.proposal, this.options.config.runtimeIdentityId)) {
+            return this.persist(checkpoint, "BLOCKED", { limitation: "Hosted grant does not match the exact approved local action binding." });
+        }
+        if (!checkpoint.execution) {
+            if (grant.status !== "ISSUED" || expired(stringValue(grantPayload.expiresAt), this.now()))
+                return this.persist(checkpoint, "EXPIRED");
+            const claim = await this.options.store.claimExecution(actionId, this.workerId, this.now().toISOString());
+            if (!claim.acquired) {
+                checkpoint = await this.persist(checkpoint, "UNKNOWN_RESULT", {
+                    executionClaimId: claim.claimId,
+                    limitation: "Another Gateway process owns the durable execution claim. This worker will only reconcile and will never dispatch.",
+                });
+                const reconciled = await this.options.runtime.reconcile({ action, proposal: checkpoint.proposal, grant });
+                if (!reconciled)
+                    return checkpoint;
+                checkpoint = await this.persist(checkpoint, "EXECUTED", { execution: reconciled, limitation: undefined });
+            }
+            else {
+                checkpoint = await this.persist(checkpoint, "EXECUTION_STARTED", { executionClaimId: claim.claimId });
+            }
+        }
+        if (!checkpoint.execution && checkpoint.phase === "EXECUTION_STARTED") {
+            if (!checkpoint.hostedReservation) {
+                const reservation = await this.options.runtime.prepareClaim({ action, proposal: checkpoint.proposal, grant });
+                if (!exactHostedReservation(reservation, actionId, grant.id))
+                    return this.persist(checkpoint, "BLOCKED", { limitation: "Runtime claim is not bound to the exact action, grant, and execution session." });
+                const claimed = await this.options.hosted.claimExecutionGrant(grant.id, reservation.claim, `durable-worker:claim:${grant.id}`);
+                if (!claimed.acquired) {
+                    checkpoint = await this.persist(checkpoint, "UNKNOWN_RESULT", {
+                        limitation: "Hosted already has an execution reservation for this grant. This worker will only reconcile and will never dispatch.",
+                    });
+                    const reconciled = await this.options.runtime.reconcile({ action, proposal: checkpoint.proposal, grant });
+                    if (!reconciled)
+                        return checkpoint;
+                    checkpoint = await this.persist(checkpoint, "EXECUTED", { execution: reconciled, limitation: undefined });
+                }
+                else {
+                    checkpoint = await this.persist(checkpoint, "EXECUTION_STARTED", { hostedReservation: reservation });
+                }
+            }
+        }
+        if (!checkpoint.execution && checkpoint.phase === "EXECUTION_STARTED" && checkpoint.hostedReservation) {
+            try {
+                const execution = await this.options.runtime.execute({ action, proposal: checkpoint.proposal, grant, hostedReservation: checkpoint.hostedReservation });
+                checkpoint = await this.persist(checkpoint, "EXECUTED", { execution });
+            }
+            catch {
+                checkpoint = await this.persist(checkpoint, "UNKNOWN_RESULT", { limitation: "Write result is unknown. The worker will only use read-only reconciliation and will never redispatch this grant." });
+                const reconciled = await this.options.runtime.reconcile({ action, proposal: checkpoint.proposal, grant });
+                if (!reconciled)
+                    return checkpoint;
+                checkpoint = await this.persist(checkpoint, "EXECUTED", { execution: reconciled, limitation: undefined });
+            }
+        }
+        if (!checkpoint.observation) {
+            const observation = await this.options.probe.observe({ action, proposal: checkpoint.proposal, grant, execution: checkpoint.execution });
+            if (!observation.observationSource || observation.observationSource !== this.options.config.probeId)
+                throw new Error("Outcome observation did not come from the exact configured probe.");
+            checkpoint = await this.persist(checkpoint, "PROBED", { observation });
+        }
+        const verified = await this.options.hosted.verifyAction(actionId, {
+            ...checkpoint.observation,
+            executionGrantId: grant.id,
+            executionSessionId: checkpoint.execution.executionSessionId,
+        }, `durable-worker:verify:${actionId}:${checkpoint.execution.executionSessionId}`);
+        if (verified.status !== "VERIFIED" || verified.verificationSuccess !== true)
+            throw new Error("Hosted outcome verification did not establish the expected result.");
+        const receipts = await this.options.hosted.listActionReceipts(actionId);
+        const signed = receipts.find((item) => Array.isArray(item.receipt?.signatureSet) && item.receipt.signatureSet.length > 0);
+        if (!signed)
+            throw new Error("Hosted did not automatically issue a signed action receipt.");
+        return this.persist(checkpoint, "COMPLETED", { receiptId: signed.id });
+    }
+    async persist(checkpoint, phase, patch = {}) {
+        const next = { ...checkpoint, ...patch, phase, updatedAt: this.now().toISOString() };
+        if (patch.limitation === undefined && "limitation" in patch)
+            delete next.limitation;
+        await this.options.store.save(next);
+        return next;
+    }
+}
+function exactActionMatches(action, actionId, proposal, adapterId, adapterVersion) {
+    const approved = action.assuranceContext?.executionIntent;
+    const proposed = proposal.executionIntent;
+    return action.id === actionId && action.externalId === proposal.externalId && action.actionType === proposal.actionType
+        && action.targetSystem === proposal.targetSystem && sha256(action.expectedState ?? {}) === sha256(proposal.expectedState ?? {})
+        && proposed.adapterId === adapterId && runtimeAdapterVersionSatisfies(adapterVersion, proposed.adapterVersionConstraint)
+        && approved?.adapterId === proposed.adapterId && approved.adapterVersionConstraint === proposed.adapterVersionConstraint
+        && canonicalJson(approved.allowedOrigins) === canonicalJson(proposed.allowedOrigins)
+        && approved.allowedOperation === proposed.allowedOperation && approved.allowedResource === proposed.allowedResource
+        && approved.approvedParametersDigest === sha256(proposed.approvedParameters)
+        && approved.outcomePredicateDigest === sha256(proposed.outcomePredicate)
+        && approved.agentBuildId === proposed.agentBuildId && approved.agentBuildDigest === proposed.agentBuildDigest;
+}
+function exactGrantMatches(grant, actionId, proposal, runtimeIdentityId) {
+    const payload = grant.grant.payload ?? {};
+    const intent = proposal.executionIntent;
+    return payload.executionGrantId === grant.id && payload.actionId === actionId && payload.adapterId === intent.adapterId
+        && payload.adapterVersionConstraint === intent.adapterVersionConstraint && payload.expectedRuntimeIdentityId === runtimeIdentityId
+        && canonicalJson(payload.allowedOrigins) === canonicalJson(intent.allowedOrigins)
+        && payload.allowedOperation === intent.allowedOperation && payload.allowedResource === intent.allowedResource
+        && payload.agentBuildId === intent.agentBuildId && payload.agentBuildDigest === intent.agentBuildDigest
+        && payload.parametersDigest === sha256(intent.approvedParameters) && payload.outcomePredicateDigest === sha256(intent.outcomePredicate);
+}
+function exactHostedReservation(reservation, actionId, executionGrantId) {
+    if (!reservation || typeof reservation !== "object" || typeof reservation.executionSessionId !== "string"
+        || !reservation.executionSessionId || !reservation.claim || typeof reservation.claim !== "object" || Array.isArray(reservation.claim))
+        return false;
+    const payload = reservation.claim.payload;
+    return Boolean(payload && typeof payload === "object" && !Array.isArray(payload)
+        && payload.actionId === actionId
+        && payload.executionGrantId === executionGrantId
+        && payload.executionSessionId === reservation.executionSessionId);
+}
+function parseCheckpoint(raw) {
+    const value = JSON.parse(raw);
+    if (value.schemaVersion !== "witnora.durable_action_checkpoint.v0.1" || !value.actionId || !value.phase || !value.proposal || !value.proposalSha256 || !value.updatedAt) {
+        throw new Error("Durable action checkpoint is invalid.");
+    }
+    return value;
+}
+function assertProposal(value) {
+    const intent = value?.executionIntent;
+    if (!value?.externalId || !value.actionType || !value.targetSystem || !intent?.adapterId || !intent.adapterVersionConstraint
+        || !Array.isArray(intent.allowedOrigins) || !intent.allowedOrigins.length || !intent.allowedOperation || !intent.allowedResource
+        || !intent.approvedParameters || typeof intent.approvedParameters !== "object" || !intent.outcomePredicate || typeof intent.outcomePredicate !== "object"
+        || !intent.agentBuildId || !/^[a-f0-9]{64}$/.test(intent.agentBuildDigest)) {
+        throw new Error("Tracked action is missing an exact execution intent.");
+    }
+}
+function sha256(value) { return createHash("sha256").update(canonicalJson(value)).digest("hex"); }
+function expired(value, now) { return !value || !Number.isFinite(Date.parse(value)) || Date.parse(value) <= now.getTime(); }
+function stringValue(value) { return typeof value === "string" ? value : undefined; }
+function validVersion(value) { return /^v?\d+\.\d+\.\d+$/.test(value); }
+export function runtimeAdapterVersionSatisfies(version, constraint) {
+    const parsed = /^v?(\d+)\.(\d+)\.(\d+)$/.exec(version);
+    const exact = /^v?(\d+)\.(\d+)\.(\d+)$/.exec(constraint);
+    if (!parsed)
+        return false;
+    if (exact)
+        return parsed.slice(1).join(".") === exact.slice(1).join(".");
+    const compatible = /^\^v?(\d+)\.(\d+)\.(\d+)$/.exec(constraint);
+    if (!compatible)
+        return false;
+    const [major, minor, patch] = parsed.slice(1).map(Number);
+    const [requiredMajor, requiredMinor, requiredPatch] = compatible.slice(1).map(Number);
+    if (requiredMajor > 0)
+        return major === requiredMajor && (minor > requiredMinor || (minor === requiredMinor && patch >= requiredPatch));
+    if (requiredMinor > 0)
+        return major === 0 && minor === requiredMinor && patch >= requiredPatch;
+    return major === 0 && minor === 0 && patch === requiredPatch;
+}
+function terminal(phase) { return phase === "DENIED" || phase === "EXPIRED" || phase === "BLOCKED" || phase === "COMPLETED"; }
+function isMissing(error) { return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT"); }
+function isAlreadyExists(error) { return Boolean(error && typeof error === "object" && "code" in error && error.code === "EEXIST"); }
+function message(error) { return error instanceof Error ? error.message : String(error); }

package/dist/probe-process.js

@@ -0,0 +1,135 @@
+import { spawn } from "node:child_process";
+export async function inspectIsolatedOutcomeProbe(config) {
+    const result = await invokeProbeChild({ mode: "health", config });
+    if (result.ready !== true)
+        throw new Error("Independent outcome-probe child did not become ready.");
+}
+export async function observeInIsolatedOutcomeProbe(config, input) {
+    const result = await invokeProbeChild({ mode: "observe", config, input });
+    if (!result.observation || typeof result.observation !== "object" || Array.isArray(result.observation))
+        throw new Error("Independent outcome-probe child returned no bounded observation.");
+    return result.observation;
+}
+async function invokeProbeChild(request) {
+    const serializedRequest = `${JSON.stringify(request)}\n`;
+    if (Buffer.byteLength(serializedRequest) > 262_144)
+        throw new Error("Independent outcome-probe input exceeded its bounded input limit.");
+    const child = spawn(process.execPath, ["--input-type=module", "--eval", PROBE_CHILD_SOURCE], {
+        env: {}, windowsHide: true, stdio: ["pipe", "pipe", "pipe"],
+    });
+    const stdout = [];
+    const stderr = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    child.stdout.on("data", (chunk) => {
+        stdoutBytes += chunk.length;
+        if (stdoutBytes <= 65_536)
+            stdout.push(chunk);
+        else
+            child.kill();
+    });
+    child.stderr.on("data", (chunk) => {
+        stderrBytes += chunk.length;
+        if (stderrBytes <= 8_192)
+            stderr.push(chunk);
+    });
+    const timeout = setTimeout(() => child.kill(), 10_000);
+    child.stdin.end(serializedRequest);
+    const exitCode = await new Promise((resolveExit, reject) => {
+        child.once("error", reject);
+        child.once("close", resolveExit);
+    }).finally(() => clearTimeout(timeout));
+    if (stdoutBytes > 65_536)
+        throw new Error("Independent outcome-probe child exceeded its bounded output limit.");
+    const output = Buffer.concat(stdout).toString("utf8");
+    let value;
+    try {
+        value = JSON.parse(output);
+    }
+    catch {
+        throw new Error(`Independent outcome-probe child failed (${exitCode ?? "unknown"}): ${Buffer.concat(stderr).toString("utf8").slice(0, 500) || "invalid response"}`);
+    }
+    if (exitCode !== 0 || value.ok !== true)
+        throw new Error(`Independent outcome-probe child failed: ${String(value.error ?? "unknown error")}`);
+    return value;
+}
+const PROBE_CHILD_SOURCE = String.raw `
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+
+const chunks = [];
+let bytes = 0;
+for await (const chunk of process.stdin) {
+  bytes += chunk.length;
+  if (bytes > 262144) throw new Error("probe_input_too_large");
+  chunks.push(chunk);
+}
+
+try {
+  const request = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  const config = request.config ?? {};
+  const moduleBytes = await readFile(config.modulePath);
+  const digest = createHash("sha256").update(moduleBytes).digest("hex");
+  if (digest !== config.moduleSha256) throw new Error("probe_module_digest_mismatch");
+  const loaded = await import(pathToFileURL(config.modulePath).href + "?sha256=" + digest);
+  if (typeof loaded.createWitnoraOutcomeProbe !== "function") throw new Error("probe_factory_missing");
+  const context = Object.freeze({
+    probeId: config.probeId,
+    projectId: config.projectId,
+    targetReadCredential: Object.freeze({ handle: config.credentialHandle, access: "READ_ONLY" }),
+  });
+  const probe = await loaded.createWitnoraOutcomeProbe(context);
+  if (probe?.id !== config.probeId || probe?.credentialHandle !== config.credentialHandle || probe?.readOnly !== true || typeof probe?.observe !== "function") throw new Error("probe_contract_mismatch");
+  if (request.mode === "health") {
+    respond({ ok: true, ready: true });
+  } else if (request.mode === "observe") {
+    const raw = await probe.observe(request.input ?? {});
+    const observedState = record(raw?.observedState, "observedState");
+    rejectSecrets(observedState);
+    const allowedMethods = new Set(["TARGET_API", "TARGET_UI", "TARGET_AUDIT_LOG", "WEBHOOK", "DATABASE_QUERY", "THIRD_PARTY_CONFIRMATION"]);
+    if (!allowedMethods.has(raw?.observationMethod) || raw?.observationSource !== config.probeId) throw new Error("probe_observation_binding_invalid");
+    const references = raw.evidenceReferences === undefined ? undefined : strings(raw.evidenceReferences, 20);
+    const confidence = raw.confidence === undefined ? undefined : Number(raw.confidence);
+    if (confidence !== undefined && (!Number.isFinite(confidence) || confidence < 0 || confidence > 1)) throw new Error("probe_confidence_invalid");
+    respond({ ok: true, observation: {
+      observedState,
+      observationMethod: raw.observationMethod,
+      observationSource: raw.observationSource,
+      ...(references ? { evidenceReferences: references } : {}),
+      ...(confidence === undefined ? {} : { confidence }),
+    } });
+  } else {
+    throw new Error("probe_mode_invalid");
+  }
+} catch (error) {
+  respond({ ok: false, error: error instanceof Error ? error.message.slice(0, 200) : "probe_failed" }, 1);
+}
+
+function record(value, name) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(name + "_invalid");
+  return value;
+}
+function strings(value, maximum) {
+  if (!Array.isArray(value) || value.length > maximum || value.some((item) => typeof item !== "string" || item.length > 512)) throw new Error("probe_evidence_references_invalid");
+  return value;
+}
+function rejectSecrets(value, depth = 0) {
+  if (depth > 8) throw new Error("probe_observation_too_deep");
+  for (const [key, child] of Object.entries(value)) {
+    if (/(authorization|cookie|password|secret|token|credential|api.?key|private.?key)/i.test(key)) throw new Error("probe_observation_contains_secret_field");
+    if (typeof child === "string" && child.length > 4096) throw new Error("probe_observation_string_too_large");
+    if (child && typeof child === "object") rejectSecrets(child, depth + 1);
+  }
+}
+function respond(value, code = 0) {
+  const output = JSON.stringify(value);
+  if (Buffer.byteLength(output) > 65536) {
+    process.stdout.write(JSON.stringify({ ok: false, error: "probe_output_too_large" }));
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(output);
+  process.exitCode = code;
+}
+`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "witnora",
-  "version": "0.13.3",
+  "version": "0.13.4",
   "description": "Independent assurance for covered agent action paths across models and frameworks.",
   "type": "module",
   "license": "Apache-2.0",