witnora 0.13.7 → 0.13.9

package/README.md

@@ -1,5 +1,14 @@
 # Witnora CLI
 
+## Customer Evaluator Kit
+
+`witnora/evaluator-kit` exports `createBusinessTaskEvaluatorServer()` for the customer-side
+Replay and Shadow evaluator consumed by the managed Workflow Harness. It listens only on a
+literal loopback address, requires a pinned bearer credential and contract digest, validates
+the exact Business Task binding, and returns only the structured evaluation report. Customer
+scenario inputs and candidate callbacks stay in the customer process. Replay can execute only
+through the supplied synthetic sandbox harness; Shadow exposes no write interface.
+
 Unified release assurance, evidence, corpus, monitor, and lab CLI for Witnora.
 
 Witnora checks what an agent may do, whether it passed pre-release evidence,

package/dist/cli.js

@@ -39,7 +39,7 @@ import { runOnboard } from "./onboard.js";
 import { inspectRepository } from "./onboard.js";
 import { renderReleaseEvaluation, runReleaseEvaluation } from "./release-evaluation.js";
 import { runPrivateCapabilityDiscovery } from "./private-discovery.js";
-import { doctorCustomerGateway, initializeCustomerGateway, isGatewayDoctorReady, readManagedCustomerGatewayLogs, renderGatewayDoctor, renderManagedGatewayStatus, restartManagedCustomerGateway, runCustomerGateway, startManagedCustomerGateway, statusManagedCustomerGateway, stopManagedCustomerGateway, } from "./gateway.js";
+import { configureManagedWorkflowHarness, doctorCustomerGateway, initializeCustomerGateway, isGatewayDoctorReady, readManagedCustomerGatewayLogs, renderGatewayDoctor, renderManagedGatewayStatus, restartManagedCustomerGateway, runCustomerGateway, startManagedCustomerGateway, statusManagedCustomerGateway, stopManagedCustomerGateway, } from "./gateway.js";
 import { verifyEvidencePacketV02 } from "./evidence-v02.js";
 process.on("uncaughtException", reportFatalError);
 process.on("unhandledRejection", reportFatalError);
@@ -231,8 +231,25 @@ else if (command === "gateway") {
     else if (action === "run") {
         await runCustomerGateway({ repository: readFlag("--repo") ?? process.cwd(), dir: readFlag("--dir") });
     }
+    else if (action === "workflow-harness") {
+        const workflowIds = process.argv.flatMap((argument, index) => argument === "--workflow" && process.argv[index + 1] ? [process.argv[index + 1]] : []);
+        const evaluatorOrigin = readFlag("--evaluator-origin");
+        const evaluatorCredentialHandle = readFlag("--evaluator-credential-handle");
+        const evaluatorContractSha256 = readFlag("--evaluator-contract-sha256");
+        if (!workflowIds.length || !evaluatorOrigin || !evaluatorCredentialHandle || !evaluatorContractSha256) {
+            throw new Error("Use witnora gateway workflow-harness --workflow <id> --evaluator-origin http://127.0.0.1:<port>/ --evaluator-credential-handle file://... --evaluator-contract-sha256 <sha256>.");
+        }
+        const result = await configureManagedWorkflowHarness({
+            repository: readFlag("--repo") ?? process.cwd(), dir: readFlag("--dir"), workflowIds,
+            evaluatorOrigin, evaluatorCredentialHandle, evaluatorContractSha256,
+            pollIntervalMs: readFlag("--poll-ms") ? Number(readFlag("--poll-ms")) : undefined,
+            maxConcurrency: readFlag("--max-concurrency") ? Number(readFlag("--max-concurrency")) : undefined,
+            force: readBoolFlag("--force"),
+        });
+        process.stdout.write(`Configured the Managed Workflow Harness for ${result.config.workflowIds.length} exact Workflow Contract(s).\nConfig: ${result.path}\nRestart the managed Gateway to activate it.\n`);
+    }
     else {
-        throw new Error("Use witnora gateway init|doctor|start|status|logs|restart|stop|run.");
+        throw new Error("Use witnora gateway init|doctor|start|status|logs|restart|stop|run|workflow-harness.");
     }
 }
 else if (command === "discover") {

package/dist/command-help.js

@@ -65,6 +65,8 @@ Options:
   witnora gateway restart
   witnora gateway stop
   witnora gateway run
+  witnora gateway workflow-harness --workflow <id> --evaluator-origin http://127.0.0.1:<port>/ \\
+    --evaluator-credential-handle file://... --evaluator-contract-sha256 <sha256>
 
 Initializes and manages a customer-owned, metadata-only collector beside the Agent.
 The browser approval issues a collector-scoped credential; no API key is copied into
@@ -86,6 +88,12 @@ Options:
   --force                 Replace an existing reviewed local setup
   --json                  JSON status output
   --lines <count>         Number of recent log lines (default: 100)
+  --workflow <id>         Exact active Workflow Contract (repeatable)
+  --evaluator-origin      Literal-loopback customer evaluator origin
+  --evaluator-credential-handle  Opaque file:// bearer credential reference
+  --evaluator-contract-sha256    Pinned evaluator contract digest
+  --poll-ms <milliseconds>       Workflow plan interval (1000-60000)
+  --max-concurrency <count>      Bounded ready evaluations (1-16)
 `;
     if (command === "design-partner")
         return `Usage:

package/dist/gateway.js

@@ -13,6 +13,7 @@ import { generateRuntimeSandboxKit, LOCAL_SANDBOX_ADAPTER_ID, LOCAL_SANDBOX_ADAP
 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";
+const WORKFLOW_HARNESS_SCHEMA = "witnora.managed_workflow_harness.v0.1";
 export async function initializeCustomerGateway(options) {
     const repository = resolve(options.repository ?? process.cwd());
     const outDir = resolve(repository, options.outDir ?? ".witnora/gateway");
@@ -468,6 +469,10 @@ export async function runCustomerGateway(options) {
         throw new Error("The saved Gateway credential does not match gateway.json. Run gateway init again.");
     }
     const dataDirectory = resolve(directory, config.storageDirectory);
+    const workflowHarnessConfigPath = join(directory, "workflow-harness.json");
+    const workflowHarnessConfig = await exists(workflowHarnessConfigPath)
+        ? parseManagedWorkflowHarnessConfig(await readFile(workflowHarnessConfigPath, "utf8"))
+        : undefined;
     const keyRingPath = join(dataDirectory, "source-keys.json");
     const keyRing = await (await exists(keyRingPath)
         ? CustomerSourceKeyRing.open(keyRingPath)
@@ -489,6 +494,16 @@ export async function runCustomerGateway(options) {
                 FileActionCheckpointStore: (await durableWorker).FileActionCheckpointStore,
             })
             : undefined;
+        const workflowHarness = workflowHarnessConfig
+            ? await createConfiguredWorkflowHarness({
+                directory,
+                projectId: config.projectId,
+                server: config.server,
+                apiKey: connection.apiKey,
+                config: workflowHarnessConfig,
+                managed: await configManagedWorkflowHarnessImport(),
+            })
+            : undefined;
         actionWorker?.start();
         const gateway = await startCustomerOwnedCollectorGateway({
             client: new RemoteCollectorClient({ baseUrl: connection.server, projectId: connection.projectId, apiKey: connection.apiKey }),
@@ -533,12 +548,15 @@ export async function runCustomerGateway(options) {
                         } } : {}),
                 } } : {}),
         });
+        workflowHarness?.start();
         process.stdout.write(`Witnora customer-owned Gateway listening on ${gateway.baseUrl}\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");
+        if (workflowHarness)
+            process.stdout.write("Managed Workflow Harness: CONFIGURED. Only authority-ready Replay and no-write Shadow evaluations will be sent to the pinned customer evaluator.\n");
         for (const signal of ["SIGINT", "SIGTERM"]) {
-            process.once(signal, () => void Promise.allSettled([gateway.close(), ...(sandboxFixture ? [sandboxFixture.close()] : [])]).finally(() => process.exit(0)));
+            process.once(signal, () => void Promise.allSettled([gateway.close(), ...(workflowHarness ? [workflowHarness.close()] : []), ...(sandboxFixture ? [sandboxFixture.close()] : [])]).finally(() => process.exit(0)));
         }
     }
     catch (error) {
@@ -546,6 +564,76 @@ export async function runCustomerGateway(options) {
         throw error;
     }
 }
+function configManagedWorkflowHarnessImport() {
+    return import(new URL("./vendor/onegent-runtime/managed-workflow-harness.js", import.meta.url).href);
+}
+export async function createConfiguredWorkflowHarness(input) {
+    const requestFetch = input.fetch ?? fetch;
+    const credential = await readSecretProviderHandle(input.config.evaluatorCredentialHandle);
+    const health = await requestFetch(`${input.config.evaluatorOrigin}/healthz`, {
+        headers: { authorization: `Bearer ${credential}` },
+        redirect: "error",
+        signal: AbortSignal.timeout(2_000),
+    });
+    const healthBody = await health.json().catch(() => ({}));
+    if (!health.ok
+        || healthBody.schemaVersion !== "witnora.business_task_evaluator.v0.1"
+        || healthBody.contractSha256 !== input.config.evaluatorContractSha256
+        || healthBody.ready !== true) {
+        throw new Error("Managed Workflow evaluator health did not match its pinned local contract.");
+    }
+    const hosted = input.managed.createManagedWorkflowHostedClient({
+        baseUrl: input.server,
+        projectId: input.projectId,
+        apiKey: input.apiKey,
+        workflowIds: input.config.workflowIds,
+        fetch: requestFetch,
+    });
+    const worker = new input.managed.ManagedBusinessWorkflowHarness({
+        client: hosted,
+        checkpoints: new input.managed.FileWorkflowEvaluationCheckpointStore(join(input.directory, "data", "workflow-evaluations")),
+        maxConcurrency: input.config.maxConcurrency,
+        evaluate: async ({ task, evaluation }) => {
+            const response = await requestFetch(`${input.config.evaluatorOrigin}/v1/evaluate`, {
+                method: "POST",
+                headers: { authorization: `Bearer ${credential}`, "content-type": "application/json" },
+                body: JSON.stringify({ schemaVersion: "witnora.business_task_evaluation_request.v0.1", task, evaluation }),
+                redirect: "error",
+                signal: AbortSignal.timeout(120_000),
+            });
+            const body = await response.json().catch(() => ({}));
+            if (!response.ok || !body.report || typeof body.report !== "object" || Array.isArray(body.report)) {
+                throw new Error(`Managed Workflow evaluator failed (${response.status}).`);
+            }
+            return body.report;
+        },
+    });
+    let timer;
+    let closing = false;
+    const tick = async () => {
+        const result = await worker.tick();
+        if ((result.evaluationsFailed ?? 0) > 0) {
+            process.stderr.write(`Managed Workflow Harness stopped ${result.evaluationsFailed} evaluation(s) fail-closed. ${result.limitations?.[0] ?? "Inspect the customer evaluator and retry."}\n`);
+        }
+        return result;
+    };
+    return {
+        start() {
+            if (timer || closing)
+                return;
+            void tick().catch((error) => process.stderr.write(`Managed Workflow Harness tick failed: ${error instanceof Error ? error.message : "unknown error"}\n`));
+            timer = setInterval(() => void tick().catch((error) => process.stderr.write(`Managed Workflow Harness tick failed: ${error instanceof Error ? error.message : "unknown error"}\n`)), input.config.pollIntervalMs ?? 5_000);
+            timer.unref?.();
+        },
+        async close() {
+            closing = true;
+            if (timer)
+                clearInterval(timer);
+            timer = undefined;
+        },
+        tick,
+    };
+}
 async function runtimeSandboxFixtureReady(config) {
     try {
         if (config.adapterId !== LOCAL_SANDBOX_ADAPTER_ID || !config.sandboxOrigin || !config.probeTargetCredentialHandle || !config.fixtureContractSha256)
@@ -936,6 +1024,63 @@ function parseConfig(raw) {
     }
     return config;
 }
+export function parseManagedWorkflowHarnessConfig(raw) {
+    const value = JSON.parse(raw);
+    if (value.schemaVersion !== WORKFLOW_HARNESS_SCHEMA
+        || value.enabled !== true
+        || !literalLoopbackOrigin(value.evaluatorOrigin)
+        || !credentialHandle(value.evaluatorCredentialHandle ?? "")
+        || !validDigest(value.evaluatorContractSha256 ?? "")
+        || !Array.isArray(value.workflowIds)
+        || !value.workflowIds.length
+        || value.workflowIds.length > 100
+        || new Set(value.workflowIds).size !== value.workflowIds.length
+        || value.workflowIds.some((id) => typeof id !== "string" || !/^[A-Za-z0-9._:-]{1,200}$/.test(id))) {
+        throw new Error("workflow-harness.json requires an enabled, digest-pinned literal-loopback evaluator and a local credential handle.");
+    }
+    if (value.pollIntervalMs !== undefined && (!Number.isInteger(value.pollIntervalMs) || value.pollIntervalMs < 1_000 || value.pollIntervalMs > 60_000)) {
+        throw new Error("workflow-harness.json pollIntervalMs must be between 1000 and 60000.");
+    }
+    if (value.maxConcurrency !== undefined && (!Number.isInteger(value.maxConcurrency) || value.maxConcurrency < 1 || value.maxConcurrency > 16)) {
+        throw new Error("workflow-harness.json maxConcurrency must be between 1 and 16.");
+    }
+    return value;
+}
+export async function configureManagedWorkflowHarness(options) {
+    const directory = resolve(options.repository ?? process.cwd(), options.dir ?? ".witnora/gateway");
+    if (!await exists(join(directory, "gateway.json")))
+        throw new Error("Initialize the customer-owned Gateway before configuring its Workflow Harness.");
+    const config = parseManagedWorkflowHarnessConfig(JSON.stringify({
+        schemaVersion: WORKFLOW_HARNESS_SCHEMA,
+        enabled: true,
+        evaluatorOrigin: options.evaluatorOrigin,
+        evaluatorCredentialHandle: options.evaluatorCredentialHandle,
+        evaluatorContractSha256: options.evaluatorContractSha256,
+        workflowIds: options.workflowIds,
+        ...(options.pollIntervalMs === undefined ? {} : { pollIntervalMs: options.pollIntervalMs }),
+        ...(options.maxConcurrency === undefined ? {} : { maxConcurrency: options.maxConcurrency }),
+    }));
+    const path = join(directory, "workflow-harness.json");
+    await writeExclusive(path, `${JSON.stringify(config, null, 2)}\n`, options.force ?? false, 0o600);
+    return { path, config };
+}
+function literalLoopbackOrigin(value) {
+    if (typeof value !== "string")
+        return false;
+    try {
+        const url = new URL(value);
+        return url.protocol === "http:"
+            && (url.hostname === "127.0.0.1" || url.hostname === "[::1]")
+            && url.username === ""
+            && url.password === ""
+            && url.pathname === "/"
+            && url.search === ""
+            && url.hash === "";
+    }
+    catch {
+        return false;
+    }
+}
 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)

package/dist/vendor/onegent-runtime/business-task-evaluator.d.ts

@@ -0,0 +1,49 @@
+import type { SandboxCertificationHarness } from "./sandbox-harness.js";
+import { type ShadowCandidateEvaluation, type TaskCandidateEvaluation, type TaskEvaluationContract, type TaskEvaluationScenario } from "./task-evaluation.js";
+export declare const BUSINESS_TASK_EVALUATOR_SCHEMA_VERSION: "witnora.business_task_evaluator.v0.1";
+export declare const BUSINESS_TASK_EVALUATION_REQUEST_SCHEMA_VERSION: "witnora.business_task_evaluation_request.v0.1";
+export interface BusinessTaskEvaluationBinding {
+    nodeId: string;
+    taskContractId: string;
+    taskContractDigestSha256: string;
+    taskKey: string;
+    agentId: string;
+    agentVersion: string;
+    mode: "REPLAY" | "SHADOW";
+}
+export interface BusinessTaskEvaluatorServerOptions {
+    credential: string;
+    contractSha256: string;
+    host?: "127.0.0.1" | "::1";
+    port?: number;
+    maxBodyBytes?: number;
+    maxConcurrency?: number;
+    evaluationTimeoutMs?: number;
+    loadReplayScenarios?(task: TaskEvaluationContract, binding: BusinessTaskEvaluationBinding, signal: AbortSignal): Promise<TaskEvaluationScenario[]>;
+    createReplayHarness?(task: TaskEvaluationContract, binding: BusinessTaskEvaluationBinding, signal: AbortSignal): Promise<{
+        harness: SandboxCertificationHarness;
+        tenantId: string;
+    }>;
+    evaluateReplayCandidate?(scenario: {
+        id: string;
+        source: TaskEvaluationScenario["source"];
+        input: unknown;
+    }, task: TaskEvaluationContract, binding: BusinessTaskEvaluationBinding, signal: AbortSignal): Promise<TaskCandidateEvaluation>;
+    loadShadowObservations?(task: TaskEvaluationContract, binding: BusinessTaskEvaluationBinding, signal: AbortSignal): Promise<TaskEvaluationScenario[]>;
+    evaluateShadowCandidate?(context: {
+        id: string;
+        source: "LIVE_SHADOW";
+        input: unknown;
+        propose: (intent: {
+            pathId: string;
+            parametersDigestSha256: string;
+        }) => void;
+    }, task: TaskEvaluationContract, binding: BusinessTaskEvaluationBinding, signal: AbortSignal): Promise<ShadowCandidateEvaluation>;
+}
+export declare function createBusinessTaskEvaluatorServer(options: BusinessTaskEvaluatorServerOptions): {
+    start(): Promise<{
+        origin: string;
+    }>;
+    close(): Promise<void>;
+};
+//# sourceMappingURL=business-task-evaluator.d.ts.map

package/dist/vendor/onegent-runtime/business-task-evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"business-task-evaluator.d.ts","sourceRoot":"","sources":["../../../../onegent-runtime/src/business-task-evaluator.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAGL,KAAK,yBAAyB,EAC9B,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAE3B,KAAK,sBAAsB,EAC5B,MAAM,sBAAsB,CAAC;AAE9B,eAAO,MAAM,sCAAsC,EAAG,sCAA+C,CAAC;AACtG,eAAO,MAAM,+CAA+C,EAAG,+CAAwD,CAAC;AAExH,MAAM,WAAW,6BAA6B;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,wBAAwB,EAAE,MAAM,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAC;CAC3B;AAED,MAAM,WAAW,kCAAkC;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,CAAC,EAAE,WAAW,GAAG,KAAK,CAAC;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,mBAAmB,CAAC,CAAC,IAAI,EAAE,sBAAsB,EAAE,OAAO,EAAE,6BAA6B,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAAC;IACnJ,mBAAmB,CAAC,CAAC,IAAI,EAAE,sBAAsB,EAAE,OAAO,EAAE,6BAA6B,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,2BAA2B,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACrL,uBAAuB,CAAC,CAAC,QAAQ,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,sBAAsB,CAAC,QAAQ,CAAC,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,EAAE,IAAI,EAAE,sBAAsB,EAAE,OAAO,EAAE,6BAA6B,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAC1O,sBAAsB,CAAC,CAAC,IAAI,EAAE,sBAAsB,EAAE,OAAO,EAAE,6BAA6B,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAAC;IACtJ,uBAAuB,CAAC,CAAC,OAAO,EAAE;QAChC,EAAE,EAAE,MAAM,CAAC;QACX,MAAM,EAAE,aAAa,CAAC;QACtB,KAAK,EAAE,OAAO,CAAC;QACf,OAAO,EAAE,CAAC,MAAM,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,sBAAsB,EAAE,MAAM,CAAA;SAAE,KAAK,IAAI,CAAC;KAC/E,EAAE,IAAI,EAAE,sBAAsB,EAAE,OAAO,EAAE,6BAA6B,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAAC;CACnI;AAED,wBAAgB,iCAAiC,CAAC,OAAO,EAAE,kCAAkC;aA+C1E,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;aAQ3B,OAAO,CAAC,IAAI,CAAC;EAK/B"}

package/dist/vendor/onegent-runtime/business-task-evaluator.js

@@ -0,0 +1,185 @@
+import { timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+import { runReplayEvaluation, runShadowEvaluation, } from "./task-evaluation.js";
+export const BUSINESS_TASK_EVALUATOR_SCHEMA_VERSION = "witnora.business_task_evaluator.v0.1";
+export const BUSINESS_TASK_EVALUATION_REQUEST_SCHEMA_VERSION = "witnora.business_task_evaluation_request.v0.1";
+export function createBusinessTaskEvaluatorServer(options) {
+    const host = options.host ?? "127.0.0.1";
+    if (host !== "127.0.0.1" && host !== "::1")
+        throw new Error("Business Task Evaluator accepts only a literal loopback host.");
+    const credential = required(options.credential, "credential");
+    const contractSha256 = digest(options.contractSha256, "contractSha256");
+    const port = bounded(options.port ?? 0, 0, 65_535, "port");
+    const maxBodyBytes = bounded(options.maxBodyBytes ?? 1_048_576, 1_024, 4_194_304, "maxBodyBytes");
+    const maxConcurrency = bounded(options.maxConcurrency ?? 4, 1, 16, "maxConcurrency");
+    const evaluationTimeoutMs = bounded(options.evaluationTimeoutMs ?? 120_000, 1_000, 600_000, "evaluationTimeoutMs");
+    const modes = [
+        ...(options.loadReplayScenarios && options.createReplayHarness && options.evaluateReplayCandidate ? ["REPLAY"] : []),
+        ...(options.loadShadowObservations && options.evaluateShadowCandidate ? ["SHADOW"] : []),
+    ];
+    let active = 0;
+    const server = createServer(async (request, response) => {
+        response.setHeader("cache-control", "no-store");
+        response.setHeader("content-type", "application/json; charset=utf-8");
+        try {
+            if (!authorized(request, credential))
+                return send(response, 401, { error: "unauthorized" });
+            if (request.method === "GET" && request.url === "/healthz") {
+                return send(response, 200, {
+                    schemaVersion: BUSINESS_TASK_EVALUATOR_SCHEMA_VERSION,
+                    contractSha256,
+                    ready: modes.length > 0,
+                    modes,
+                    boundary: { host, productionWrites: 0, rawInputsRetainedByCustomer: true },
+                });
+            }
+            if (request.method !== "POST" || request.url !== "/v1/evaluate")
+                return send(response, 404, { error: "not_found" });
+            if (!String(request.headers["content-type"] ?? "").toLowerCase().startsWith("application/json")) {
+                return send(response, 415, { error: "json_required" });
+            }
+            if (active >= maxConcurrency)
+                return send(response, 429, { error: "evaluator_busy" });
+            const body = await readJson(request, maxBodyBytes);
+            const parsed = parseRequest(body);
+            validateBinding(parsed.task, parsed.evaluation);
+            active += 1;
+            try {
+                const report = await withTimeout((signal) => evaluate(options, parsed.task, parsed.evaluation, signal), evaluationTimeoutMs);
+                return send(response, 200, { schemaVersion: BUSINESS_TASK_EVALUATOR_SCHEMA_VERSION, report });
+            }
+            finally {
+                active -= 1;
+            }
+        }
+        catch (error) {
+            const status = error instanceof EvaluatorError ? error.status : 422;
+            return send(response, status, { error: error instanceof EvaluatorError ? error.code : "evaluation_failed" });
+        }
+    });
+    return {
+        async start() {
+            if (!server.listening)
+                await new Promise((resolve, reject) => {
+                    server.once("error", reject);
+                    server.listen(port, host, () => { server.off("error", reject); resolve(); });
+                });
+            const address = server.address();
+            return { origin: `http://${host === "::1" ? "[::1]" : host}:${address.port}` };
+        },
+        async close() {
+            if (!server.listening)
+                return;
+            await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+        },
+    };
+}
+async function evaluate(options, task, binding, signal) {
+    if (binding.mode === "REPLAY") {
+        if (!options.loadReplayScenarios || !options.createReplayHarness || !options.evaluateReplayCandidate) {
+            throw new EvaluatorError(409, "replay_not_configured");
+        }
+        const [{ harness, tenantId }, scenarios] = await Promise.all([
+            options.createReplayHarness(task, binding, signal), options.loadReplayScenarios(task, binding, signal),
+        ]);
+        return runReplayEvaluation({
+            task, harness, tenantId, scenarios,
+            evaluateCandidate: (scenario) => options.evaluateReplayCandidate(scenario, task, binding, signal),
+        });
+    }
+    if (!options.loadShadowObservations || !options.evaluateShadowCandidate)
+        throw new EvaluatorError(409, "shadow_not_configured");
+    return runShadowEvaluation({
+        task,
+        observations: await options.loadShadowObservations(task, binding, signal),
+        evaluateCandidate: (context) => options.evaluateShadowCandidate(context, task, binding, signal),
+    });
+}
+function parseRequest(input) {
+    const body = object(input, "request");
+    exactKeys(body, ["schemaVersion", "task", "evaluation"], "request");
+    if (body.schemaVersion !== BUSINESS_TASK_EVALUATION_REQUEST_SCHEMA_VERSION)
+        throw new EvaluatorError(422, "invalid_schema");
+    const evaluation = object(body.evaluation, "evaluation");
+    exactKeys(evaluation, ["nodeId", "taskContractId", "taskContractDigestSha256", "taskKey", "agentId", "agentVersion", "mode"], "evaluation");
+    if (evaluation.mode !== "REPLAY" && evaluation.mode !== "SHADOW")
+        throw new EvaluatorError(422, "invalid_mode");
+    const binding = {
+        nodeId: requiredString(evaluation.nodeId), taskContractId: requiredString(evaluation.taskContractId),
+        taskContractDigestSha256: digest(String(evaluation.taskContractDigestSha256 ?? ""), "taskContractDigestSha256"),
+        taskKey: requiredString(evaluation.taskKey), agentId: requiredString(evaluation.agentId),
+        agentVersion: requiredString(evaluation.agentVersion), mode: evaluation.mode,
+    };
+    return { task: object(body.task, "task"), evaluation: binding };
+}
+function validateBinding(task, binding) {
+    if (task.id !== binding.taskContractId || task.digestSha256 !== binding.taskContractDigestSha256
+        || task.taskKey !== binding.taskKey || task.subject?.agentId !== binding.agentId
+        || task.subject?.agentVersion !== binding.agentVersion)
+        throw new EvaluatorError(409, "task_binding_mismatch");
+}
+function authorized(request, credential) {
+    const supplied = String(request.headers.authorization ?? "").replace(/^Bearer\s+/i, "");
+    const left = Buffer.from(supplied);
+    const right = Buffer.from(credential);
+    return left.length === right.length && left.length > 0 && timingSafeEqual(left, right);
+}
+async function readJson(request, limit) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += value.length;
+        if (size > limit)
+            throw new EvaluatorError(413, "body_too_large");
+        chunks.push(value);
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    }
+    catch {
+        throw new EvaluatorError(400, "invalid_json");
+    }
+}
+async function withTimeout(execute, timeoutMs) {
+    const controller = new AbortController();
+    let timer;
+    try {
+        return await Promise.race([execute(controller.signal), new Promise((_, reject) => {
+                timer = setTimeout(() => { controller.abort(); reject(new EvaluatorError(504, "evaluation_timeout")); }, timeoutMs);
+                timer.unref?.();
+            })]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+function send(response, status, body) { response.statusCode = status; response.end(JSON.stringify(body)); }
+function object(value, name) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new EvaluatorError(422, `invalid_${name}`);
+    return value;
+}
+function exactKeys(value, allowed, name) {
+    const keys = new Set(allowed);
+    if (Object.keys(value).some((key) => !keys.has(key)))
+        throw new EvaluatorError(422, `unexpected_${name}_field`);
+}
+function required(value, name) { const result = value.trim(); if (!result)
+    throw new Error(`${name} is required.`); return result; }
+function requiredString(value) { if (typeof value !== "string" || !value.trim())
+    throw new EvaluatorError(422, "invalid_binding"); return value.trim(); }
+function digest(value, name) { if (!/^[a-f0-9]{64}$/.test(value))
+    throw new Error(`${name} must be a lowercase SHA-256 digest.`); return value; }
+function bounded(value, min, max, name) { if (!Number.isInteger(value) || value < min || value > max)
+    throw new Error(`${name} must be between ${min} and ${max}.`); return value; }
+class EvaluatorError extends Error {
+    status;
+    code;
+    constructor(status, code) {
+        super(code);
+        this.status = status;
+        this.code = code;
+    }
+}

package/dist/vendor/onegent-runtime/managed-workflow-harness.d.ts

@@ -0,0 +1,92 @@
+import type { TaskEvaluationContract, TaskEvaluationReport } from "./task-evaluation.js";
+export type ManagedWorkflowEvaluationMode = "REPLAY" | "SHADOW";
+export interface ManagedWorkflowExecutionPlan {
+    schemaVersion: "witnora.business_workflow_execution_plan.v0.1";
+    projectId: string;
+    generatedAt: string;
+    workflow: {
+        id: string;
+        digestSha256: string;
+        status: "ACTIVE" | "RETIRED";
+    };
+    nodes: Array<{
+        id: string;
+        status: "BLOCKED" | "READY" | "RUNNING" | "NEEDS_DECISION" | "COMPLETED";
+    }>;
+    readyEvaluations: ManagedWorkflowReadyEvaluation[];
+    recordsTruncated: boolean;
+    safety: {
+        productionWrites: 0;
+        aggregateAssuranceClaim: false;
+        customerHarnessRequired: true;
+    };
+    limitations: string[];
+}
+export interface ManagedWorkflowReadyEvaluation {
+    nodeId: string;
+    taskContractId: string;
+    taskContractDigestSha256: string;
+    taskKey: string;
+    agentId: string;
+    agentVersion: string;
+    mode: ManagedWorkflowEvaluationMode;
+}
+export interface ManagedWorkflowHostedClient {
+    listActiveWorkflows(): Promise<Array<{
+        id: string;
+        digestSha256: string;
+        status: "ACTIVE" | "RETIRED";
+    }>>;
+    getExecutionPlan(workflowId: string): Promise<ManagedWorkflowExecutionPlan>;
+    getTask(taskContractId: string): Promise<TaskEvaluationContract>;
+    upload(report: TaskEvaluationReport, input: {
+        externalId: string;
+    }): Promise<unknown>;
+}
+export declare function createManagedWorkflowHostedClient(options: {
+    baseUrl: string;
+    projectId: string;
+    apiKey: string;
+    workflowIds?: string[];
+    fetch?: typeof fetch;
+}): ManagedWorkflowHostedClient;
+export interface WorkflowEvaluationCheckpointStore {
+    load(key: string): Promise<TaskEvaluationReport | undefined>;
+    save(key: string, report: TaskEvaluationReport): Promise<void>;
+    complete(key: string): Promise<void>;
+}
+export declare class MemoryWorkflowEvaluationCheckpointStore implements WorkflowEvaluationCheckpointStore {
+    #private;
+    load(key: string): Promise<TaskEvaluationReport | undefined>;
+    save(key: string, report: TaskEvaluationReport): Promise<void>;
+    complete(key: string): Promise<void>;
+}
+export declare class FileWorkflowEvaluationCheckpointStore implements WorkflowEvaluationCheckpointStore {
+    private readonly directory;
+    constructor(directory: string);
+    load(key: string): Promise<TaskEvaluationReport | undefined>;
+    save(key: string, report: TaskEvaluationReport): Promise<void>;
+    complete(key: string): Promise<void>;
+    private path;
+}
+export interface ManagedBusinessWorkflowHarnessResult {
+    workflowsInspected: number;
+    evaluationsCompleted: number;
+    evaluationsFailed: number;
+    limitations: string[];
+}
+export declare class ManagedBusinessWorkflowHarness {
+    #private;
+    constructor(options: {
+        client: ManagedWorkflowHostedClient;
+        checkpoints: WorkflowEvaluationCheckpointStore;
+        evaluate: (input: {
+            task: TaskEvaluationContract;
+            evaluation: ManagedWorkflowReadyEvaluation;
+        }) => Promise<TaskEvaluationReport>;
+        maxConcurrency?: number;
+    });
+    tick(): Promise<ManagedBusinessWorkflowHarnessResult>;
+    private runTick;
+}
+//# sourceMappingURL=managed-workflow-harness.d.ts.map

package/dist/vendor/onegent-runtime/managed-workflow-harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-workflow-harness.d.ts","sourceRoot":"","sources":["../../../../onegent-runtime/src/managed-workflow-harness.ts"],"names":[],"mappings":"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"}