witnora 0.13.2 → 0.13.3

package/README.md

@@ -353,7 +353,7 @@ Control semantics and attestation format:
 [release gate checklist](https://github.com/Kakarottoooo/agentcert/blob/main/docs/release-gate-checklist.md).
 
 CI users can run Tripwire and Witnora together with
-`Kakarottoooo/agentcert/actions/tripwire@v0`.
+`Kakarottoooo/witnora/actions/tripwire@v0`.
 
 The public Real Agent Robustness Lab compares browser-use, Stagehand, and
 Playwright-based agents over the same fault suite:

package/dist/conformance.js

@@ -10,7 +10,7 @@ const SUPPORTED_TOP_LEVEL_FIELDS = new Set([
 export async function runEvidenceConformance(input, options) {
     const checks = [];
     const schema = validateAgentCertSchema("evidence-bundle", input);
-    checks.push(check("schema", "Evidence bundle satisfies the AgentCert v0.1 semantic contract.", schema.errors));
+    checks.push(check("schema", "Witnora evidence satisfies the stable agentcert v0.1 protocol contract.", schema.errors));
     const bundle = object(input);
     const compatibilityErrors = bundle
         ? Object.keys(bundle).filter((key) => !SUPPORTED_TOP_LEVEL_FIELDS.has(key)).map((key) => `Unsupported top-level field: ${key}.`)

package/dist/control-plane.js

@@ -397,7 +397,7 @@ async function requestJson(request, url, init) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        throw new ControlPlaneRequestError(`AgentCert control plane request failed: ${message}`);
+        throw new ControlPlaneRequestError(`Witnora control plane request failed: ${message}`);
     }
     const text = await response.text();
     let value = {};
@@ -407,12 +407,12 @@ async function requestJson(request, url, init) {
         }
         catch {
             if (!response.ok)
-                throw new ControlPlaneRequestError(`AgentCert control plane returned HTTP ${response.status}.`, response.status);
-            throw new ControlPlaneRequestError("AgentCert control plane returned invalid JSON.", response.status);
+                throw new ControlPlaneRequestError(`Witnora control plane returned HTTP ${response.status}.`, response.status);
+            throw new ControlPlaneRequestError("Witnora control plane returned invalid JSON.", response.status);
         }
     }
     if (!response.ok) {
-        throw new ControlPlaneRequestError([typeof value.error === "string" ? value.error : `AgentCert control plane returned HTTP ${response.status}.`,
+        throw new ControlPlaneRequestError([typeof value.error === "string" ? value.error : `Witnora control plane returned HTTP ${response.status}.`,
             typeof value.recovery === "string" ? value.recovery : undefined,
             typeof value.requestId === "string" ? `Request ID: ${value.requestId}.` : undefined].filter(Boolean).join(" "), response.status, typeof value.code === "string" ? value.code : undefined, typeof value.requestId === "string" ? value.requestId : response.headers.get("x-request-id") ?? undefined, typeof value.recovery === "string" ? value.recovery : undefined);
     }

package/dist/gateway.js

@@ -36,7 +36,7 @@ export async function initializeCustomerGateway(options) {
             output,
             configHome: options.configHome,
         });
-    const expectedScopes = ["runs:read", "events:write", "collector:manage"];
+    const expectedScopes = ["runs:read", "events:write", "collector:manage", "actions:read", "actions:propose", "actions:execute"];
     const missingScopes = expectedScopes.filter((scope) => !authorization.scopes.includes(scope));
     if (missingScopes.length > 0)
         throw new Error(`Gateway authorization is missing required scope(s): ${missingScopes.join(", ")}.`);
@@ -156,7 +156,11 @@ export async function doctorCustomerGateway(options) {
     };
 }
 export async function runCustomerGateway(options) {
-    const { CustomerSourceKeyRing, RemoteCollectorClient, startCustomerOwnedCollectorGateway, } = await import("agentcert-sdk");
+    const remoteCollector = await import(new URL("./internal/control-client/remote-collector.js", import.meta.url).href);
+    const collectorGateway = await import(new URL("./internal/control-client/collector-gateway.js", import.meta.url).href);
+    const CustomerSourceKeyRing = remoteCollector.CustomerSourceKeyRing;
+    const RemoteCollectorClient = remoteCollector.RemoteCollectorClient;
+    const startCustomerOwnedCollectorGateway = collectorGateway.startCustomerOwnedCollectorGateway;
     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"));
@@ -405,6 +409,13 @@ function gatewayReadme(config) {
     return `# Witnora customer-owned Gateway\n\nThis directory configures a metadata-only Gateway for project \`${config.projectId}\`. The Setup Autopilot starts it in the background after browser authorization.\n\n## Operations\n\n\`\`\`bash\nnpx witnora@latest gateway status\nnpx witnora@latest gateway logs\nnpx witnora@latest gateway restart\nnpx witnora@latest gateway stop\n\`\`\`\n\n\`gateway run\` remains available as a foreground debugging command. In the Agent repository, import the generated client at one meaningful sandbox workflow boundary:\n\n\`\`\`js\nimport { randomUUID } from "node:crypto";\nimport { witnoraGateway } from "./.witnora/gateway/client.mjs";\n\nconst runId = randomUUID();\nawait witnoraGateway.start(runId, { workflow: "sandbox-workflow" });\ntry {\n  // Run the existing customer workflow here. Do not add raw inputs or outputs.\n  await witnoraGateway.event(runId, "workflow.step.completed", { step: "meaningful-boundary" });\n  await witnoraGateway.complete(runId, { status: "completed" });\n} catch (error) {\n  await witnoraGateway.event(runId, "workflow.failed", { errorType: error?.name ?? "Error" });\n  await witnoraGateway.complete(runId, { status: "failed" });\n  throw error;\n}\n\`\`\`\n\nThe generated client reads only the local ignored Gateway token and sends metadata to \`http://${config.host}:${config.port}\`. The Hosted API key and source-signing key stay in the Gateway process. Do not commit \`secrets.json\`, \`data/\`, or \`runtime/\`.\n\nThis reference process creates source-signed, durable **RECORDED** evidence. It does not claim complete mediation. **ENFORCED** requires the target write credential to be removed from the Agent and placed behind a controlled execution adapter. **OUTCOME VERIFIED** requires a separate read-only credential and independent probe.\n`;
 }
 function gatewayClient(config) {
+    const requestHelper = `async function actionRequest(path, init = {}) {\n  const headers = new Headers(init.headers);\n  headers.set("authorization", \`Bearer \${await token()}\`);\n  if (init.body) headers.set("content-type", "application/json");\n  const response = await fetch(\`\${baseUrl}\${path}\`, { ...init, headers });\n  const result = await response.json().catch(() => ({}));\n  if (!response.ok) throw new Error(result.error ?? \`Witnora Gateway returned HTTP \${response.status}.\`);\n  return result;\n}\n`;
+    const actionMethods = `  proposeAction(proposal, idempotencyKey = proposal?.externalId) {\n    if (typeof idempotencyKey !== "string" || !idempotencyKey) throw new Error("Witnora action proposal requires an idempotency key or externalId.");\n    return actionRequest("/v1/actions", { method: "POST", body: JSON.stringify({ proposal, idempotencyKey }) });\n  },\n  getAction(actionId) {\n    if (!/^[A-Za-z0-9._:-]+$/.test(actionId)) throw new Error("Witnora actionId contains unsupported characters.");\n    return actionRequest(\`/v1/actions/\${encodeURIComponent(actionId)}\`);\n  },\n  issueExecutionGrant(actionId, grant, idempotencyKey = \`grant:\${actionId}\`) {\n    if (!/^[A-Za-z0-9._:-]+$/.test(actionId)) throw new Error("Witnora actionId contains unsupported characters.");\n    return actionRequest(\`/v1/actions/\${encodeURIComponent(actionId)}/execution-grant\`, { method: "POST", body: JSON.stringify({ grant, idempotencyKey }) });\n  },\n`;
+    return recordedGatewayClient(config)
+        .replace("export const witnoraGateway = {", `${requestHelper}\nexport const witnoraGateway = {`)
+        .replace(/\n};\n$/, `\n${actionMethods}};\n`);
+}
+function recordedGatewayClient(config) {
     return `import { readFile } from "node:fs/promises";\n\nconst baseUrl = "http://${config.host}:${config.port}";\nlet gatewayToken;\n\nasync function token() {\n  if (gatewayToken) return gatewayToken;\n  const secrets = JSON.parse(await readFile(new URL("./secrets.json", import.meta.url), "utf8"));\n  if (typeof secrets.gatewayToken !== "string" || secrets.gatewayToken.length < 32) {\n    throw new Error("Witnora local Gateway token is missing or invalid.");\n  }\n  gatewayToken = secrets.gatewayToken;\n  return gatewayToken;\n}\n\nasync function post(runId, operation, body) {\n  if (!/^[A-Za-z0-9._:-]+$/.test(runId)) throw new Error("Witnora runId contains unsupported characters.");\n  const response = await fetch(\`\${baseUrl}/v1/runs/\${encodeURIComponent(runId)}/\${operation}\`, {\n    method: "POST",\n    headers: { authorization: \`Bearer \${await token()}\`, "content-type": "application/json" },\n    body: JSON.stringify(body),\n  });\n  const result = await response.json().catch(() => ({}));\n  if (!response.ok) throw new Error(result.error ?? \`Witnora Gateway returned HTTP \${response.status}.\`);\n  return result;\n}\n\nexport const witnoraGateway = {\n  start(runId, metadata = {}) {\n    return post(runId, "start", { payload: metadata, idempotencyKey: "run-start" });\n  },\n  event(runId, type, metadata = {}, idempotencyKey = \`\${type}-\${crypto.randomUUID()}\`) {\n    return post(runId, "events", { type, payload: metadata, idempotencyKey });\n  },\n  complete(runId, metadata = {}) {\n    return post(runId, "complete", {\n      payload: metadata,\n      evidenceStrength: {\n        schemaVersion: "agentcert.evidence_strength.v0.1",\n        level: "recorded",\n        claims: [],\n        limitations: ["No write-credential mediation or independent outcome probe is configured."],\n      },\n      idempotencyKey: "run-complete",\n    });\n  },\n};\n`;
 }
 async function writeExclusive(path, content, force, mode) {

package/dist/internal/control-client/canonical.d.ts

@@ -0,0 +1,2 @@
+export declare function canonicalJson(value: unknown): string;
+//# sourceMappingURL=canonical.d.ts.map

package/dist/internal/control-client/canonical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical.d.ts","sourceRoot":"","sources":["../../../../agentcert-sdk/src/canonical.ts"],"names":[],"mappings":"AAAA,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEpD"}

package/dist/internal/control-client/canonical.js

@@ -0,0 +1,19 @@
+export function canonicalJson(value) {
+    return JSON.stringify(canonicalValue(value));
+}
+function canonicalValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new Error("Canonical JSON does not support non-finite numbers.");
+        return Object.is(value, -0) ? 0 : value;
+    }
+    if (Array.isArray(value))
+        return value.map(canonicalValue);
+    if (value && typeof value === "object") {
+        const record = value;
+        return Object.fromEntries(Object.keys(record).sort().filter((key) => record[key] !== undefined).map((key) => [key, canonicalValue(record[key])]));
+    }
+    throw new Error(`Canonical JSON does not support ${typeof value}.`);
+}

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

@@ -0,0 +1,55 @@
+import { CustomerSourceKeyRing, type CustomerSourceSigner, type RemoteCollectorAck, type RemoteTrustedSourceRecord } from "./remote-collector.js";
+export interface RemoteCollectorTransport {
+    registerSourceKey(input: {
+        collectorId: string;
+        keyId: string;
+        publicKeyPem: string;
+        previousKeyId?: string;
+    }): Promise<Record<string, unknown>>;
+    append(runId: string, records: RemoteTrustedSourceRecord[], idempotencyKey?: string): Promise<RemoteCollectorAck>;
+    heartbeat(input: {
+        collectorId: string;
+        signer: CustomerSourceSigner;
+        pendingRecordCount: number;
+        lastAckSequence?: number;
+    }): Promise<Record<string, unknown>>;
+    reconcile(runId: string, receipt: Record<string, unknown>): Promise<Record<string, unknown>>;
+    proposeAction(proposal: Record<string, unknown>, idempotencyKey: string): Promise<Record<string, unknown>>;
+    getAction(actionId: string): Promise<Record<string, unknown>>;
+    issueExecutionGrant(actionId: string, grant: Record<string, unknown>, idempotencyKey: string): Promise<Record<string, unknown>>;
+}
+export interface CustomerOwnedCollectorGatewayOptions {
+    client: RemoteCollectorTransport;
+    keyRing: CustomerSourceKeyRing;
+    gatewayToken: string;
+    storageDirectory: string;
+    collectorVersion?: string;
+    environment?: string;
+    host?: string;
+    port?: number;
+    flushIntervalMs?: number;
+    heartbeatIntervalMs?: number;
+    maxBodyBytes?: number;
+}
+export interface CustomerOwnedCollectorGateway {
+    baseUrl: string;
+    close(): Promise<void>;
+    flush(): Promise<{
+        delivered: number;
+        reconciled: number;
+        pending: number;
+    }>;
+    status(): Promise<CollectorGatewayStatus>;
+}
+export interface CollectorGatewayStatus {
+    schemaVersion: "agentcert.customer_collector_gateway_status.v0.2";
+    collectorId: string;
+    sourceKeyId: string;
+    runCount: number;
+    pendingRecordCount: number;
+    lastAckSequence?: number;
+    lastRemoteSuccessAt?: string;
+    lastRemoteError?: string;
+}
+export declare function startCustomerOwnedCollectorGateway(options: CustomerOwnedCollectorGatewayOptions): Promise<CustomerOwnedCollectorGateway>;
+//# sourceMappingURL=collector-gateway.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,386 @@
+import { createHash, createPublicKey, sign, timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { canonicalJson } from "./canonical.js";
+import { DurableRemoteCollectorQueue, RemoteCollectorApiError, } from "./remote-collector.js";
+export async function startCustomerOwnedCollectorGateway(options) {
+    if (options.gatewayToken.length < 24)
+        throw new Error("gatewayToken must contain at least 24 characters.");
+    const storageDirectory = resolve(options.storageDirectory);
+    await mkdir(storageDirectory, { recursive: true });
+    const signer = options.keyRing.activeSigner();
+    let sourceKeyRegistered = false;
+    const journals = new Map();
+    const activeCollector = {
+        id: options.keyRing.collectorId,
+        version: options.collectorVersion ?? "0.2.0",
+        environment: options.environment ?? "customer-owned",
+        keyId: signer.keyId,
+        publicKeySha256: publicKeyFingerprint(signer.publicKeyPem),
+    };
+    let lastRemoteSuccessAt;
+    let lastRemoteError;
+    const ensureSourceKeyRegistered = async () => {
+        if (sourceKeyRegistered)
+            return;
+        await options.client.registerSourceKey(options.keyRing.registration());
+        sourceKeyRegistered = true;
+    };
+    const journalFor = async (runId) => {
+        identifier(runId, "runId");
+        const existing = journals.get(runId);
+        if (existing)
+            return existing;
+        const queue = new DurableRemoteCollectorQueue(storageDirectory, runId);
+        const first = (await queue.all())[0];
+        const runSigner = first ? options.keyRing.signerFor(first.collector.keyId) : signer;
+        const journal = await GatewayRunJournal.open(storageDirectory, runId, first?.collector ?? activeCollector, runSigner);
+        journals.set(runId, journal);
+        return journal;
+    };
+    const flush = async () => {
+        let delivered = 0;
+        let reconciled = 0;
+        let pending = 0;
+        try {
+            await ensureSourceKeyRegistered();
+        }
+        catch (error) {
+            lastRemoteError = message(error);
+        }
+        for (const journal of journals.values()) {
+            try {
+                if (!sourceKeyRegistered)
+                    throw new Error(lastRemoteError ?? "Collector source key is not registered.");
+                delivered += (await journal.queue.replay(options.client)).delivered;
+                if (await journal.reconcileIfReady(options.client))
+                    reconciled += 1;
+                lastRemoteSuccessAt = new Date().toISOString();
+                lastRemoteError = undefined;
+            }
+            catch (error) {
+                lastRemoteError = message(error);
+            }
+            pending += (await journal.queue.pending()).length;
+        }
+        return { delivered, reconciled, pending };
+    };
+    const status = async () => {
+        let pendingRecordCount = 0;
+        let lastAckSequence;
+        for (const journal of journals.values()) {
+            pendingRecordCount += (await journal.queue.pending()).length;
+            const ack = await journal.queue.currentAck();
+            if (ack.sequence >= 0)
+                lastAckSequence = Math.max(lastAckSequence ?? -1, ack.sequence);
+        }
+        return {
+            schemaVersion: "agentcert.customer_collector_gateway_status.v0.2",
+            collectorId: activeCollector.id,
+            sourceKeyId: activeCollector.keyId,
+            runCount: journals.size,
+            pendingRecordCount,
+            lastAckSequence,
+            lastRemoteSuccessAt,
+            lastRemoteError,
+        };
+    };
+    const server = createServer(async (request, response) => {
+        try {
+            const url = new URL(request.url ?? "/", "http://127.0.0.1");
+            if (request.method === "GET" && url.pathname === "/healthz")
+                return json(response, 200, await status());
+            authenticate(request, options.gatewayToken);
+            if (request.method === "POST" && url.pathname === "/v1/flush")
+                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 actionRoute = url.pathname.match(/^\/v1\/actions\/([A-Za-z0-9._:-]+)$/);
+            if (request.method === "GET" && actionRoute) {
+                return json(response, 200, await options.client.getAction(identifier(actionRoute[1], "actionId")));
+            }
+            const grantRoute = url.pathname.match(/^\/v1\/actions\/([A-Za-z0-9._:-]+)\/execution-grant$/);
+            if (request.method === "POST" && grantRoute) {
+                const actionId = identifier(grantRoute[1], "actionId");
+                const action = await options.client.getAction(actionId);
+                if (action.status !== "APPROVED" && action.status !== "ALLOWED") {
+                    throw new GatewayRequestError(409, `Action ${actionId} is not approved for execution.`);
+                }
+                const body = await readJson(request, options.maxBodyBytes ?? 1_048_576);
+                return json(response, 201, await options.client.issueExecutionGrant(actionId, object(body.grant), identifier(body.idempotencyKey, "idempotencyKey")));
+            }
+            const route = url.pathname.match(/^\/v1\/runs\/([A-Za-z0-9._:-]+)\/(start|events|drops|complete)$/);
+            if (!route)
+                return json(response, 404, { error: "not found" });
+            const runId = route[1];
+            const operation = route[2];
+            const body = await readJson(request, options.maxBodyBytes ?? 1_048_576);
+            const journal = await journalFor(runId);
+            let record;
+            if (operation === "start") {
+                record = await journal.append("RUN_STARTED", object(body.payload), String(body.idempotencyKey ?? "run-start"));
+            }
+            else if (operation === "events") {
+                record = await journal.append(identifier(body.type, "type"), object(body.payload), identifier(body.idempotencyKey, "idempotencyKey"));
+            }
+            else if (operation === "drops") {
+                const count = positiveInteger(body.count, "count");
+                record = await journal.append("EVENTS_DROPPED", { count, reason: required(body.reason, "reason") }, identifier(body.idempotencyKey, "idempotencyKey"), count);
+            }
+            else {
+                const input = body;
+                record = await journal.append("RUN_COMPLETED", object(input.payload), String(input.idempotencyKey ?? "run-complete"));
+                await journal.writeReceipt({
+                    mandateDigests: strings(input.mandateDigests),
+                    actionIds: strings(input.actionIds),
+                    evidenceStrength: object(input.evidenceStrength),
+                });
+            }
+            const remote = await flush();
+            return json(response, 202, { durable: true, record, remote });
+        }
+        catch (error) {
+            if (error instanceof RemoteCollectorApiError) {
+                const status = Number.isInteger(error.status) && error.status >= 400 && error.status <= 599 ? error.status : 502;
+                return json(response, status, status === error.status ? {
+                    error: error.message,
+                    code: error.code,
+                    ...(error.recovery ? { recovery: error.recovery } : {}),
+                } : { error: "Hosted API returned an invalid error response.", code: "remote_collector_invalid_status" });
+            }
+            const statusCode = error instanceof GatewayRequestError ? error.status : 500;
+            return json(response, statusCode, { error: message(error) });
+        }
+    });
+    await listen(server, options.port ?? 0, options.host ?? "127.0.0.1");
+    const address = server.address();
+    if (!address || typeof address === "string")
+        throw new Error("Collector gateway did not bind a TCP port.");
+    const flushTimer = setInterval(() => void flush(), options.flushIntervalMs ?? 5_000);
+    const heartbeatTimer = setInterval(async () => {
+        const current = await status();
+        try {
+            await ensureSourceKeyRegistered();
+            await options.client.heartbeat({
+                collectorId: activeCollector.id,
+                signer,
+                pendingRecordCount: current.pendingRecordCount,
+                lastAckSequence: current.lastAckSequence,
+            });
+            lastRemoteSuccessAt = new Date().toISOString();
+            lastRemoteError = undefined;
+        }
+        catch (error) {
+            lastRemoteError = message(error);
+        }
+    }, options.heartbeatIntervalMs ?? 30_000);
+    flushTimer.unref();
+    heartbeatTimer.unref();
+    for (const runId of await discoverRunIds(storageDirectory))
+        await journalFor(runId);
+    await flush();
+    return {
+        baseUrl: `http://${options.host ?? "127.0.0.1"}:${address.port}`,
+        close: async () => {
+            clearInterval(flushTimer);
+            clearInterval(heartbeatTimer);
+            await flush();
+            await close(server);
+        },
+        flush,
+        status,
+    };
+}
+class GatewayRunJournal {
+    runId;
+    collector;
+    signer;
+    queue;
+    records;
+    chain = Promise.resolve();
+    receiptPath;
+    reconciliationPath;
+    constructor(directory, runId, collector, signer, records) {
+        this.runId = runId;
+        this.collector = collector;
+        this.signer = signer;
+        this.queue = new DurableRemoteCollectorQueue(directory, runId);
+        this.records = records;
+        const base = safeFileName(runId);
+        this.receiptPath = join(resolve(directory), `${base}.receipt.json`);
+        this.reconciliationPath = join(resolve(directory), `${base}.reconciled.json`);
+    }
+    static async open(directory, runId, collector, signer) {
+        const queue = new DurableRemoteCollectorQueue(directory, runId);
+        const records = await queue.all();
+        for (let index = 0; index < records.length; index += 1) {
+            const record = records[index];
+            if (record.runId !== runId || canonicalJson(record.collector) !== canonicalJson(collector))
+                throw new Error(`Stored gateway journal for ${runId} has a different collector identity.`);
+            if (index > 0 && record.previousEventHash !== records[index - 1].eventHash)
+                throw new Error(`Stored gateway journal for ${runId} has a broken hash chain.`);
+        }
+        return new GatewayRunJournal(directory, runId, collector, signer, records);
+    }
+    async append(type, payload, idempotencyKey, skippedSequences = 0) {
+        identifier(idempotencyKey, "idempotencyKey");
+        let result;
+        const operation = this.chain.then(async () => {
+            const recordId = sha256(`${this.runId}:${idempotencyKey}`);
+            const replay = this.records.find((record) => record.recordId === recordId);
+            if (replay) {
+                if (replay.type !== type || canonicalJson(replay.payload) !== canonicalJson(payload))
+                    throw new GatewayRequestError(409, `idempotencyKey ${idempotencyKey} was already used with different content.`);
+                result = replay;
+                return;
+            }
+            if (this.records.at(-1)?.type === "RUN_COMPLETED")
+                throw new GatewayRequestError(409, `Run ${this.runId} is already complete.`);
+            if (this.records.length === 0 && type !== "RUN_STARTED")
+                throw new GatewayRequestError(409, `Run ${this.runId} must start before appending records.`);
+            const previous = this.records.at(-1);
+            const occurredAt = new Date().toISOString();
+            const payloadSha256 = sha256(canonicalJson(payload));
+            const unsigned = {
+                schemaVersion: "agentcert.trusted_action_record.v0.1",
+                recordId,
+                runId: this.runId,
+                sequence: (previous?.sequence ?? -1) + 1 + skippedSequences,
+                occurredAt,
+                type,
+                collector: this.collector,
+                previousEventHash: previous?.eventHash,
+                payload,
+                payloadSha256,
+            };
+            const eventHash = sha256(canonicalJson(unsigned));
+            result = { ...unsigned, eventHash, sourceSignature: signDigest(eventHash, this.signer) };
+            await this.queue.enqueue(result);
+            this.records.push(result);
+        });
+        this.chain = operation.catch(() => undefined);
+        await operation;
+        return structuredClone(result);
+    }
+    async writeReceipt(input) {
+        const first = this.records[0];
+        const last = this.records.at(-1);
+        if (!first || last?.type !== "RUN_COMPLETED")
+            throw new Error("A completed run is required before writing a receipt.");
+        const droppedEventCount = this.records.filter((record) => record.type === "EVENTS_DROPPED")
+            .reduce((total, record) => total + Number(record.payload.count ?? 0), 0);
+        const payload = {
+            schemaVersion: "agentcert.trusted_run_receipt.v0.1",
+            runId: this.runId,
+            collector: this.collector,
+            startedAt: first.occurredAt,
+            completedAt: last.occurredAt,
+            eventCount: this.records.length,
+            droppedEventCount,
+            firstEventHash: first.eventHash,
+            lastEventHash: last.eventHash,
+            mandateDigests: [...new Set(input.mandateDigests)].sort(),
+            actionIds: [...new Set(input.actionIds)].sort(),
+            journal: { valid: true, complete: true, sourceSigned: true, gaps: [], duplicateSequences: [], duplicateRecordIds: [], hashMismatches: [], signatureFailures: [], droppedEventCount, recoveredTailBytes: 0, errors: [] },
+            evidenceStrength: input.evidenceStrength,
+            sourcePublicKeyPem: this.signer.publicKeyPem,
+        };
+        const receiptSha256 = sha256(canonicalJson(payload));
+        await writeFile(this.receiptPath, `${JSON.stringify({ ...payload, receiptSha256, sourceSignature: signDigest(receiptSha256, this.signer) }, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    }
+    async reconcileIfReady(client) {
+        if ((await this.queue.pending()).length > 0)
+            return false;
+        try {
+            await readFile(this.reconciliationPath, "utf8");
+            return false;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        let receipt;
+        try {
+            receipt = JSON.parse(await readFile(this.receiptPath, "utf8"));
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return false;
+            throw error;
+        }
+        const reconciliation = await client.reconcile(this.runId, receipt);
+        await writeFile(this.reconciliationPath, `${JSON.stringify(reconciliation)}\n`, { encoding: "utf8", mode: 0o600 });
+        return true;
+    }
+}
+class GatewayRequestError extends Error {
+    status;
+    constructor(status, messageText) {
+        super(messageText);
+        this.status = status;
+    }
+}
+function authenticate(request, expected) {
+    const actual = request.headers.authorization?.replace(/^Bearer\s+/i, "") ?? "";
+    const left = Buffer.from(actual);
+    const right = Buffer.from(expected);
+    if (left.length !== right.length || !timingSafeEqual(left, right))
+        throw new GatewayRequestError(401, "Gateway authentication failed.");
+}
+async function readJson(request, maxBytes) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const value = Buffer.from(chunk);
+        size += value.length;
+        if (size > maxBytes)
+            throw new GatewayRequestError(413, `Request body exceeds ${maxBytes} bytes.`);
+        chunks.push(value);
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}");
+    }
+    catch {
+        throw new GatewayRequestError(400, "Request body must be valid JSON.");
+    }
+}
+function listen(server, port, host) {
+    return new Promise((resolvePromise, reject) => server.once("error", reject).listen(port, host, resolvePromise));
+}
+function close(server) { return new Promise((resolvePromise, reject) => server.close((error) => error ? reject(error) : resolvePromise())); }
+function json(response, status, body) { response.statusCode = status; response.setHeader("content-type", "application/json"); response.end(JSON.stringify(body)); }
+function sha256(value) { return createHash("sha256").update(value).digest("hex"); }
+function publicKeyFingerprint(publicKeyPem) { return sha256(createPublicKey(publicKeyPem).export({ type: "spki", format: "der" })); }
+function signDigest(digest, signer) {
+    return { algorithm: "Ed25519", keyId: signer.keyId, signature: sign(null, Buffer.from(digest, "hex"), signer.privateKeyPem).toString("base64url") };
+}
+function identifier(value, field) { const parsed = required(value, field); if (parsed.length > 160 || !/^[A-Za-z0-9._:-]+$/.test(parsed))
+    throw new GatewayRequestError(400, `${field} must use URL-safe identifier characters.`); return parsed; }
+function required(value, field) { if (typeof value !== "string" || !value.trim())
+    throw new GatewayRequestError(400, `${field} is required.`); return value; }
+function object(value) { if (value === undefined)
+    return {}; if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new GatewayRequestError(400, "Expected a JSON object."); return value; }
+function strings(value) { if (value === undefined)
+    return []; if (!Array.isArray(value) || value.some((item) => typeof item !== "string"))
+    throw new GatewayRequestError(400, "Expected an array of strings."); return value; }
+function positiveInteger(value, field) { if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0)
+    throw new GatewayRequestError(400, `${field} must be a positive integer.`); return value; }
+function safeFileName(value) { return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 160); }
+function message(error) { return error instanceof Error ? error.message : String(error); }
+async function discoverRunIds(directory) {
+    const runIds = new Set();
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+        if (!entry.isFile() || !entry.name.endsWith(".remote.jsonl"))
+            continue;
+        const firstLine = (await readFile(join(directory, entry.name), "utf8")).split(/\r?\n/, 1)[0];
+        if (!firstLine)
+            continue;
+        const record = JSON.parse(firstLine);
+        runIds.add(identifier(record.runId, "stored runId"));
+    }
+    return [...runIds];
+}

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

@@ -0,0 +1,132 @@
+export interface CustomerSourceSigner {
+    keyId: string;
+    privateKeyPem: string;
+    publicKeyPem: string;
+}
+export interface RemoteTrustedSourceRecord {
+    schemaVersion: "agentcert.trusted_action_record.v0.1";
+    recordId: string;
+    runId: string;
+    sequence: number;
+    occurredAt: string;
+    type: string;
+    collector: {
+        id: string;
+        version: string;
+        environment: string;
+        keyId: string;
+        publicKeySha256: string;
+    };
+    previousEventHash?: string;
+    payload: Record<string, unknown>;
+    payloadSha256: string;
+    eventHash: string;
+    sourceSignature: {
+        algorithm: "Ed25519";
+        keyId: string;
+        signature: string;
+    };
+}
+export interface RemoteCollectorAck {
+    schemaVersion: "agentcert.remote_collector_ack.v0.2";
+    accepted: number;
+    replayed: number;
+    ack: {
+        sequence: number;
+        eventHash: string;
+    };
+    alerts: Array<Record<string, unknown>>;
+    run: Record<string, unknown>;
+}
+export interface RemoteCollectorClientOptions {
+    baseUrl: string;
+    projectId: string;
+    apiKey: string;
+    fetch?: typeof fetch;
+}
+export declare class CustomerSourceKeyRing {
+    readonly filePath: string;
+    private value;
+    private constructor();
+    static create(filePath: string, collectorId: string, keyId?: string): Promise<CustomerSourceKeyRing>;
+    static open(filePath: string): Promise<CustomerSourceKeyRing>;
+    get collectorId(): string;
+    activeSigner(): CustomerSourceSigner;
+    signerFor(keyId: string): CustomerSourceSigner;
+    registration(previousKeyId?: string): {
+        collectorId: string;
+        keyId: string;
+        publicKeyPem: string;
+        previousKeyId?: string;
+    };
+    rotate(keyId?: string): Promise<{
+        previousKeyId: string;
+        signer: CustomerSourceSigner;
+    }>;
+    private persist;
+}
+export declare class RemoteCollectorClient {
+    readonly baseUrl: string;
+    readonly projectId: string;
+    private readonly apiKey;
+    private readonly requestFetch;
+    constructor(options: RemoteCollectorClientOptions);
+    registerSourceKey(input: {
+        collectorId: string;
+        keyId: string;
+        publicKeyPem: string;
+        previousKeyId?: string;
+    }): Promise<Record<string, unknown>>;
+    append(runId: string, records: RemoteTrustedSourceRecord[], idempotencyKey?: string): Promise<RemoteCollectorAck>;
+    heartbeat(input: {
+        collectorId: string;
+        signer: CustomerSourceSigner;
+        runId?: string;
+        pendingRecordCount: number;
+        lastAckSequence?: number;
+        occurredAt?: string;
+    }): Promise<Record<string, unknown>>;
+    reconcile(runId: string, receipt: Record<string, unknown>): Promise<Record<string, unknown>>;
+    proposeAction(proposal: Record<string, unknown>, idempotencyKey: string): Promise<Record<string, unknown>>;
+    getAction(actionId: string): Promise<Record<string, unknown>>;
+    issueExecutionGrant(actionId: string, grant: Record<string, unknown>, idempotencyKey: string): Promise<Record<string, unknown>>;
+    status(): Promise<Record<string, unknown>>;
+    revokeSourceKey(keyId: string): Promise<Record<string, unknown>>;
+    sink(): {
+        name: string;
+        write(record: RemoteTrustedSourceRecord): Promise<void>;
+    };
+    private json;
+}
+export declare class DurableRemoteCollectorQueue {
+    readonly runId: string;
+    readonly journalPath: string;
+    readonly ackPath: string;
+    private replayChain;
+    constructor(directory: string, runId: string);
+    enqueue(record: RemoteTrustedSourceRecord): Promise<void>;
+    pending(): Promise<RemoteTrustedSourceRecord[]>;
+    all(): Promise<RemoteTrustedSourceRecord[]>;
+    currentAck(): Promise<{
+        sequence: number;
+        eventHash?: string;
+    }>;
+    replay(client: {
+        append(runId: string, records: RemoteTrustedSourceRecord[], idempotencyKey?: string): Promise<RemoteCollectorAck>;
+    }): Promise<{
+        delivered: number;
+        ack?: {
+            sequence: number;
+            eventHash: string;
+        };
+    }>;
+    private readAck;
+    private writeAck;
+}
+export declare class RemoteCollectorApiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly recovery?: string | undefined;
+    constructor(status: number, code: string, message: string, recovery?: string | undefined);
+}
+//# sourceMappingURL=remote-collector.d.ts.map

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

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

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

@@ -0,0 +1,318 @@
+import { chmod, mkdir, open, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, randomUUID, sign } from "node:crypto";
+import { canonicalJson } from "./canonical.js";
+export class CustomerSourceKeyRing {
+    filePath;
+    value;
+    constructor(filePath, value) {
+        this.filePath = filePath;
+        this.value = value;
+    }
+    static async create(filePath, collectorId, keyId = `${collectorId}-${new Date().toISOString().slice(0, 10)}-${randomUUID().slice(0, 8)}`) {
+        identifier(collectorId, "collectorId");
+        identifier(keyId, "keyId");
+        const target = resolve(filePath);
+        try {
+            await readFile(target);
+            throw new Error(`Customer source key ring already exists at ${target}.`);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        const key = generatedKey(keyId, new Date().toISOString());
+        const ring = new CustomerSourceKeyRing(target, { schemaVersion: "agentcert.customer_source_keyring.v0.2", collectorId, activeKeyId: keyId, keys: [key] });
+        await ring.persist();
+        return ring;
+    }
+    static async open(filePath) {
+        const target = resolve(filePath);
+        const parsed = JSON.parse(await readFile(target, "utf8"));
+        validateRing(parsed);
+        return new CustomerSourceKeyRing(target, parsed);
+    }
+    get collectorId() { return this.value.collectorId; }
+    activeSigner() {
+        const key = this.value.keys.find((item) => item.keyId === this.value.activeKeyId && item.status === "active");
+        if (!key)
+            throw new Error("Customer source key ring has no active signing key.");
+        return { keyId: key.keyId, privateKeyPem: key.privateKeyPem, publicKeyPem: key.publicKeyPem };
+    }
+    signerFor(keyId) {
+        const key = this.value.keys.find((item) => item.keyId === keyId);
+        if (!key)
+            throw new Error(`Customer source key ${keyId} is not present in this key ring.`);
+        return { keyId: key.keyId, privateKeyPem: key.privateKeyPem, publicKeyPem: key.publicKeyPem };
+    }
+    registration(previousKeyId) {
+        const signer = this.activeSigner();
+        const previous = previousKeyId ?? [...this.value.keys].reverse().find((item) => item.status === "retired")?.keyId;
+        return { collectorId: this.collectorId, keyId: signer.keyId, publicKeyPem: signer.publicKeyPem, previousKeyId: previous };
+    }
+    async rotate(keyId = `${this.collectorId}-${new Date().toISOString().slice(0, 10)}-${randomUUID().slice(0, 8)}`) {
+        identifier(keyId, "keyId");
+        if (this.value.keys.some((item) => item.keyId === keyId))
+            throw new Error(`Customer source key ${keyId} already exists.`);
+        const now = new Date().toISOString();
+        const previousKeyId = this.value.activeKeyId;
+        this.value = {
+            ...this.value,
+            activeKeyId: keyId,
+            keys: [...this.value.keys.map((item) => item.keyId === previousKeyId ? { ...item, status: "retired", retiredAt: now } : item), generatedKey(keyId, now)],
+        };
+        await this.persist();
+        return { previousKeyId, signer: this.activeSigner() };
+    }
+    async persist() {
+        await mkdir(dirname(this.filePath), { recursive: true });
+        const temporary = `${this.filePath}.${process.pid}.${randomUUID()}.tmp`;
+        await writeFile(temporary, `${JSON.stringify(this.value, null, 2)}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        await chmod(temporary, 0o600);
+        await rename(temporary, this.filePath);
+    }
+}
+export class RemoteCollectorClient {
+    baseUrl;
+    projectId;
+    apiKey;
+    requestFetch;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/$/, "");
+        this.projectId = options.projectId;
+        this.apiKey = options.apiKey;
+        this.requestFetch = options.fetch ?? fetch;
+        if (!this.baseUrl || !this.projectId || !this.apiKey)
+            throw new Error("baseUrl, projectId, and apiKey are required.");
+    }
+    registerSourceKey(input) {
+        return this.json("collector-keys", { method: "POST", body: JSON.stringify(input) });
+    }
+    append(runId, records, idempotencyKey = `record-${records[0]?.eventHash ?? randomUUID()}`) {
+        return this.json(`trusted-runs/${encodeURIComponent(runId)}/records`, {
+            method: "POST",
+            headers: { "idempotency-key": idempotencyKey },
+            body: JSON.stringify({ records }),
+        });
+    }
+    heartbeat(input) {
+        const payload = {
+            schemaVersion: "agentcert.collector_heartbeat.v0.2",
+            collectorId: input.collectorId,
+            sourceKeyId: input.signer.keyId,
+            runId: input.runId,
+            occurredAt: input.occurredAt ?? new Date().toISOString(),
+            pendingRecordCount: input.pendingRecordCount,
+            lastAckSequence: input.lastAckSequence,
+        };
+        const payloadSha256 = sha256(canonicalJson(payload));
+        return this.json("collector-heartbeats", {
+            method: "POST",
+            body: JSON.stringify({ payload, payloadSha256, signature: signSourceDigest(payloadSha256, input.signer) }),
+        });
+    }
+    reconcile(runId, receipt) {
+        return this.json(`trusted-runs/${encodeURIComponent(runId)}/reconcile`, {
+            method: "POST",
+            headers: { "idempotency-key": `reconcile-${String(receipt.receiptSha256 ?? randomUUID())}` },
+            body: JSON.stringify(receipt),
+        });
+    }
+    proposeAction(proposal, idempotencyKey) {
+        return this.json("actions", {
+            method: "POST",
+            headers: { "idempotency-key": idempotencyKey },
+            body: JSON.stringify(proposal),
+        });
+    }
+    getAction(actionId) {
+        return this.json(`actions/${encodeURIComponent(actionId)}`);
+    }
+    issueExecutionGrant(actionId, grant, idempotencyKey) {
+        return this.json(`actions/${encodeURIComponent(actionId)}/execution-grant`, {
+            method: "POST",
+            headers: { "idempotency-key": idempotencyKey },
+            body: JSON.stringify(grant),
+        });
+    }
+    status() { return this.json("collector-status"); }
+    async revokeSourceKey(keyId) {
+        return this.json(`collector-keys/${encodeURIComponent(keyId)}`, { method: "DELETE" });
+    }
+    sink() {
+        return {
+            name: "agentcert-remote-collector-v0.2",
+            write: async (record) => { await this.append(record.runId, [record], `record-${record.eventHash}`); },
+        };
+    }
+    async json(suffix, init = {}) {
+        const response = await this.requestFetch(`${this.baseUrl}/v1/projects/${encodeURIComponent(this.projectId)}/${suffix}`, {
+            ...init,
+            headers: { authorization: `Bearer ${this.apiKey}`, ...(init.body ? { "content-type": "application/json" } : {}), ...init.headers },
+        });
+        const body = await response.json().catch(() => ({}));
+        if (!response.ok)
+            throw new RemoteCollectorApiError(response.status, String(body.code ?? "remote_collector_error"), String(body.error ?? `Witnora API request failed (${response.status}).`), typeof body.recovery === "string" ? body.recovery : undefined);
+        return body;
+    }
+}
+export class DurableRemoteCollectorQueue {
+    runId;
+    journalPath;
+    ackPath;
+    replayChain = Promise.resolve();
+    constructor(directory, runId) {
+        this.runId = runId;
+        this.journalPath = resolve(directory, `${safeFileName(runId)}.remote.jsonl`);
+        this.ackPath = resolve(directory, `${safeFileName(runId)}.remote-ack.json`);
+    }
+    async enqueue(record) {
+        if (record.runId !== this.runId)
+            throw new Error("Queued record runId does not match the durable queue runId.");
+        await mkdir(dirname(this.journalPath), { recursive: true });
+        const handle = await open(this.journalPath, "a");
+        try {
+            await handle.write(`${JSON.stringify(record)}\n`);
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    async pending() {
+        const records = await this.all();
+        const ack = await this.readAck();
+        validateAck(records, ack);
+        return records.filter((record) => record.sequence > ack.sequence);
+    }
+    async all() {
+        let raw = "";
+        try {
+            raw = await readFile(this.journalPath, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        }
+        return raw.split(/\r?\n/).filter(Boolean).map((line, index) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                throw new Error(`Remote collector queue contains invalid JSON at line ${index + 1}.`);
+            }
+        });
+    }
+    async currentAck() {
+        const records = await this.all();
+        const ack = await this.readAck();
+        validateAck(records, ack);
+        return ack;
+    }
+    async replay(client) {
+        let result;
+        const operation = this.replayChain.then(async () => {
+            let delivered = 0;
+            let latest;
+            for (const record of await this.pending()) {
+                const response = await client.append(record.runId, [record], `record-${record.eventHash}`);
+                latest = response.ack;
+                await this.writeAck(latest);
+                delivered += 1;
+            }
+            result = { delivered, ack: latest };
+        });
+        this.replayChain = operation.catch(() => undefined);
+        await operation;
+        return result;
+    }
+    async readAck() {
+        try {
+            const value = JSON.parse(await readFile(this.ackPath, "utf8"));
+            if (!Number.isSafeInteger(value.sequence) || Number(value.sequence) < 0 || typeof value.eventHash !== "string" || !/^[a-f0-9]{64}$/.test(value.eventHash)) {
+                throw new Error("Remote collector ACK file is invalid.");
+            }
+            return { sequence: Number(value.sequence), eventHash: value.eventHash };
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return { sequence: -1 };
+            throw error;
+        }
+    }
+    async writeAck(ack) {
+        const records = await this.all();
+        validateAck(records, ack);
+        const current = await this.readAck();
+        if (current.sequence > ack.sequence)
+            return;
+        if (current.sequence === ack.sequence) {
+            if (current.eventHash !== ack.eventHash)
+                throw new Error(`Remote collector ACK hash conflicts at sequence ${ack.sequence}.`);
+            return;
+        }
+        await mkdir(dirname(this.ackPath), { recursive: true });
+        const temporary = `${this.ackPath}.${process.pid}.${randomUUID()}.tmp`;
+        await writeFile(temporary, JSON.stringify(ack), { encoding: "utf8", mode: 0o600 });
+        await rename(temporary, this.ackPath);
+    }
+}
+function validateAck(records, ack) {
+    if (ack.sequence === -1)
+        return;
+    const acknowledged = records.find((record) => record.sequence === ack.sequence);
+    if (!acknowledged || acknowledged.eventHash !== ack.eventHash) {
+        throw new Error(`Remote collector ACK does not match the local journal at sequence ${ack.sequence}.`);
+    }
+}
+export class RemoteCollectorApiError extends Error {
+    status;
+    code;
+    recovery;
+    constructor(status, code, message, recovery) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.recovery = recovery;
+        this.name = "RemoteCollectorApiError";
+    }
+}
+function generatedKey(keyId, createdAt) {
+    const { privateKey, publicKey } = generateKeyPairSync("ed25519");
+    return {
+        keyId,
+        privateKeyPem: privateKey.export({ type: "pkcs8", format: "pem" }).toString(),
+        publicKeyPem: publicKey.export({ type: "spki", format: "pem" }).toString(),
+        createdAt,
+        status: "active",
+    };
+}
+function signSourceDigest(digest, signer) {
+    if (!/^[a-f0-9]{64}$/.test(digest))
+        throw new Error("A SHA-256 digest is required for source signing.");
+    return { algorithm: "Ed25519", keyId: signer.keyId, signature: sign(null, Buffer.from(digest, "hex"), createPrivateKey(signer.privateKeyPem)).toString("base64url") };
+}
+function validateRing(value) {
+    if (value.schemaVersion !== "agentcert.customer_source_keyring.v0.2")
+        throw new Error("Customer source key ring schemaVersion is not supported.");
+    identifier(value.collectorId, "collectorId");
+    identifier(value.activeKeyId, "activeKeyId");
+    if (!Array.isArray(value.keys) || value.keys.length === 0)
+        throw new Error("Customer source key ring has no keys.");
+    for (const key of value.keys) {
+        identifier(key.keyId, "keys[].keyId");
+        const privateKey = createPrivateKey(key.privateKeyPem);
+        const derivedPublic = createPublicKey(privateKey).export({ type: "spki", format: "pem" }).toString();
+        if (privateKey.asymmetricKeyType !== "ed25519" || derivedPublic !== createPublicKey(key.publicKeyPem).export({ type: "spki", format: "pem" }).toString()) {
+            throw new Error(`Customer source key ${key.keyId} is invalid.`);
+        }
+    }
+}
+function sha256(value) { return createHash("sha256").update(value).digest("hex"); }
+function identifier(value, field) {
+    if (!value || value.length > 160 || !/^[A-Za-z0-9._:-]+$/.test(value))
+        throw new Error(`${field} must use 1 to 160 URL-safe identifier characters.`);
+    return value;
+}
+function safeFileName(value) { return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 160); }

package/dist/onboarding-templates.js

@@ -131,7 +131,7 @@ export function starterInstructions(template, subject) {
         return `
 Next:
   1. Edit tripwire.yml so startUrl and agent.command/agent.args match your app and browser agent.
-  2. Run in CI with Kakarottoooo/agentcert/actions/tripwire@v0, or re-run init with --github-action.
+  2. Run in CI with Kakarottoooo/witnora/actions/tripwire@v0, or re-run init with --github-action.
   3. Run: npx witnora@latest run --tripwire .tripwire/latest/tripwire-result.json --subject ${JSON.stringify(subject)} --fail-on-verdict --push
 `;
     if (template === "mcp")
@@ -203,7 +203,7 @@ jobs:
         with:
           node-version: "20"
       - id: agentcert
-        uses: Kakarottoooo/agentcert/actions/tripwire@v0
+        uses: Kakarottoooo/witnora/actions/tripwire@v0
         with:
           config: tripwire.yml
           out: .tripwire/latest

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "witnora",
-  "version": "0.13.2",
+  "version": "0.13.3",
   "description": "Independent assurance for covered agent action paths across models and frameworks.",
   "type": "module",
   "license": "Apache-2.0",
@@ -41,8 +41,8 @@
       "import": "./dist/vendor/onegent-runtime/browser-adapter-kit.js"
     },
     "./deployment-enforcement": {
-      "types": "./dist/vendor/agentcert-sdk/deployment-enforcement.d.ts",
-      "import": "./dist/vendor/agentcert-sdk/deployment-enforcement.js"
+      "types": "./dist/internal/control-client/deployment-enforcement.d.ts",
+      "import": "./dist/internal/control-client/deployment-enforcement.js"
     }
   },
   "files": [
@@ -66,8 +66,5 @@
   },
   "optionalDependencies": {
     "pg": "^8.16.3"
-  },
-  "dependencies": {
-    "agentcert-sdk": "0.5.0"
   }
 }