witnora 0.9.3 → 0.10.2

package/dist/design-partner-v02.js

@@ -0,0 +1,449 @@
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { compileAssuranceContract, exampleAssuranceContract } from "./assurance-contract.js";
+import { examplePrivacyManifest } from "./privacy-manifest.js";
+import { collectSupportBundle, formatDoctorReport, formatPrivacyInspection, genericEvalExample, initializePilotState, markPilotLifecycle, pilotPackageFiles, referenceReleaseCandidateManifest, runPilotDoctor, runPilotLifecycleDemonstration, snapshotPilotRuntime, writePilotAcceptanceReport } from "./design-partner-pilot.js";
+import { createAcceptanceTrustMaterial, createGitHubAcceptanceIdentity, executionBoundaryDigest, githubActionDigest, issueAcceptanceAuthorization, readGitHubTargetState, revokeProbeCertificate, rotateProbeCertificate, runDesignPartnerAcceptance, startGitHubTargetEmulator } from "./github-design-partner-v02.js";
+import { verifyEvidencePacketV02 } from "./evidence-v02.js";
+import { assertLiveGitHubSafety, readLiveGitHubPullRequest } from "./github-live-v02.js";
+export function hardenedDesignPartnerCompose(relativeRoot = ".") {
+    return baseDesignPartnerCompose()
+        .replace("design-partner target-emulator --state", "design-partner target-emulator --dir /kit --state")
+        .replace("      - acceptance-data:/output\n", "      - ./acceptance:/output\n")
+        .replace("      - acceptance-data:/output:ro\n", "      - ./acceptance:/output:ro\n")
+        .replaceAll("context: \${WITNORA_SOURCE_ROOT:-../..}/packages/witnora-cli\n      dockerfile: Dockerfile.design-partner", "context: ./docker/runtime\n      dockerfile: Dockerfile")
+        .replace("context: \${WITNORA_SOURCE_ROOT:-../..}/packages/witnora-probe\n    command: [\"node\", \"dist/cli.js\"]", "context: ./docker/runtime\n      dockerfile: Dockerfile\n    entrypoint: [\"node\", \"/app/dist/vendor/witnora-probe/cli.js\"]")
+        .replace(/^\s{2}acceptance-data: \{\}\r?\n/mu, "")
+        .replaceAll("- ./", `- ${relativeRoot}/`)
+        .replaceAll("file: ./secrets/", `file: ${relativeRoot}/secrets/`)
+        .replaceAll("context: ./docker/runtime", `context: ${relativeRoot}/docker/runtime`);
+}
+export async function runDesignPartnerCommand(args) {
+    const action = args[0] ?? "help";
+    if (action === "init")
+        return init(args);
+    if (action === "doctor")
+        return doctor(args);
+    if (action === "dry-run")
+        return dryRun(args);
+    if (action === "run-acceptance")
+        return acceptance(args);
+    if (action === "recover-acceptance")
+        return acceptance([...args, "--recover-only"]);
+    if (action === "prepare-live-github")
+        return prepareLiveGitHub(args);
+    if (action === "authorization" && args[1] === "issue")
+        return issueAuthorization(args);
+    if (action === "verify-offline")
+        return verifyOffline(args);
+    if (action === "privacy" && args[1] === "inspect")
+        return inspectPrivacy(args);
+    if (action === "collect-support-bundle")
+        return supportBundle(args);
+    if (action === "pilot-report")
+        return pilotReport(args);
+    if (action === "pilot-lifecycle")
+        return pilotLifecycle(args);
+    if (action === "trust" && args[1] === "inspect")
+        return inspectTrust(args);
+    if (action === "trust" && args[1] === "revoke-probe")
+        return revokeProbe(args);
+    if (action === "trust" && args[1] === "rotate-probe")
+        return rotateProbe(args);
+    if (action === "target-emulator")
+        return targetEmulator(args);
+    if (action === "help" || action === "--help" || action === "-h") {
+        process.stdout.write(help());
+        return;
+    }
+    throw new Error(`Unknown design-partner command: ${action}. Run 'witnora design-partner --help'.`);
+}
+async function init(args) {
+    if ((args[1] ?? "github-pr-merge") !== "github-pr-merge")
+        throw new Error("Only github-pr-merge is supported in v0.2.");
+    const outDir = resolve(flag(args, "--out") ?? ".witnora/design-partner");
+    const trustDir = join(outDir, "trust");
+    const secretsDir = join(outDir, "secrets");
+    await Promise.all([mkdir(trustDir, { recursive: true }), mkdir(secretsDir, { recursive: true })]);
+    const declaredTarget = { owner: "witnora-design-partner", repository: "assurance-sandbox", pullRequestNumber: 17, baseBranch: "acceptance", baseSha: "base-a", headBranch: "agent-change", headSha: "head-a", open: true, merged: false, checks: { build: "success", policy: "success" }, mergeable: true, targetVersion: 1 };
+    const config = { protocolVersion: "witnora.design_partner_github.v0.2", tenantRef: "tenant:design-partner", projectRef: "project:github-sandbox", environment: "sandbox", targetUrl: "http://target-sandbox:4311", probeUrl: "http://probe:4312", readCredentialEnv: "WITNORA_GITHUB_READ_CREDENTIAL", writeCredentialEnv: "WITNORA_GITHUB_WRITE_CREDENTIAL", trustDir: "./trust", legacyUnprotectedPathEnabled: false, declaredTarget };
+    const trust = createAcceptanceTrustMaterial({ tenantRef: config.tenantRef, projectRef: config.projectRef, environment: config.environment });
+    const contract = exampleAssuranceContract();
+    contract.subject.agentId = "design-partner-github-agent";
+    contract.subject.environment = "sandbox";
+    contract.capability.id = "github.pull_request.merge";
+    contract.capability.action = "UPDATE";
+    const files = {
+        "design-partner.json": JSON.stringify(config, null, 2),
+        "witnora.assurance-contract.json": JSON.stringify(contract, null, 2),
+        "witnora.privacy-manifest.json": JSON.stringify(examplePrivacyManifest(), null, 2),
+        ".env.example": "# Synthetic emulator values only; do not reuse for a live sandbox.\nWITNORA_GITHUB_READ_CREDENTIAL=local-emulator-read-only\nWITNORA_GITHUB_WRITE_CREDENTIAL=local-emulator-write-only\nWITNORA_TARGET_URL=http://127.0.0.1:4311\nWITNORA_PROBE_URL=http://127.0.0.1:4312\nWITNORA_PROBE_STORAGE_KEY_BASE64=AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=\n",
+        ".gitignore": "secrets/\nprobe/data/\nacceptance/\nclaims/\nsupport-bundle/\n.env\n",
+        "sandbox-policy.json": JSON.stringify({ repositories: ["witnora-design-partner/assurance-sandbox"], protectedBranches: ["main", "master"], liveModeDefault: false }, null, 2),
+        "acceptance-checklist.md": checklist(),
+        "docker-compose.yml": hardenedDesignPartnerCompose("."),
+        "docker/compose.yml": hardenedDesignPartnerCompose(".."),
+        "trust/pinned-root.json": JSON.stringify(trust.root, null, 2),
+        "trust/gateway-certificate.json": JSON.stringify(trust.gatewayCertificate, null, 2),
+        "trust/request-signer-certificate.json": JSON.stringify(trust.requestSignerCertificate, null, 2),
+        "trust/probe-certificate.json": JSON.stringify(trust.probeCertificate, null, 2),
+        "trust/approval-certificate.json": JSON.stringify(trust.approvalCertificate, null, 2),
+        "trust/grant-certificate.json": JSON.stringify(trust.grantCertificate, null, 2),
+        "trust/revocation-journal.json": JSON.stringify(trust.journal, null, 2),
+        "probe/config.json": JSON.stringify(probeConfig(config, trust, "http://127.0.0.1:4311", "./data", "../secrets/probe-private.pem"), null, 2),
+        "probe/config.container.json": JSON.stringify(probeConfig(config, trust, "http://target-sandbox:4311", "/app/data", "/app/keys/probe-private.pem"), null, 2),
+        "probe/request-signer-public.pem": trust.requestSignerCertificate.publicKeyPem,
+        "secrets/root-private.pem": trust.rootPrivateKeyPem,
+        "secrets/request-signer-private.pem": trust.requestSignerPrivateKeyPem,
+        "secrets/gateway-private.pem": trust.gatewayPrivateKeyPem,
+        "secrets/probe-private.pem": trust.probePrivateKeyPem,
+        "secrets/approval-private.pem": trust.approvalPrivateKeyPem,
+        "secrets/grant-private.pem": trust.grantPrivateKeyPem,
+    };
+    const customerFiles = pilotPackageFiles(config);
+    customerFiles["contract/assurance-contract.json"] = JSON.stringify(contract, null, 2);
+    customerFiles["privacy/privacy-manifest.json"] = JSON.stringify(examplePrivacyManifest(), null, 2);
+    customerFiles["examples/generic-eval.json"] = JSON.stringify(genericEvalExample(compileAssuranceContract(contract).revalidationFingerprint), null, 2);
+    Object.assign(files, customerFiles);
+    await Promise.all(Object.entries(files).map(async ([relative, content]) => { const path = join(outDir, relative); await mkdir(resolve(path, ".."), { recursive: true }); await writeFile(path, `${content.trimEnd()}\n`, { flag: "wx" }); }));
+    for (const secret of [join(secretsDir, "root-private.pem"), join(secretsDir, "request-signer-private.pem"), join(secretsDir, "gateway-private.pem"), join(secretsDir, "probe-private.pem"), join(secretsDir, "approval-private.pem"), join(secretsDir, "grant-private.pem")])
+        await chmod(secret, 0o600).catch(() => undefined);
+    await writeFile(join(outDir, "target-state.json"), `${JSON.stringify(declaredTarget, null, 2)}\n`);
+    await snapshotPilotRuntime(outDir);
+    await Promise.all([mkdir(join(outDir, "acceptance"), { recursive: true }), mkdir(join(outDir, "claims"), { recursive: true })]);
+    await initializePilotState(outDir);
+    await writeFile(join(outDir, "release-candidate-manifest.json"), `${JSON.stringify(referenceReleaseCandidateManifest(), null, 2)}\n`);
+    process.stdout.write(`Initialized the self-contained GitHub design-partner kit at ${outDir}\n\nNext:\n  1. Open QUICKSTART.md. The first run uses local synthetic credentials only.\n  2. Issue a short-lived signed approval and Grant.\n  3. Start the Docker Compose topology.\n  4. Run doctor, privacy inspect, and dry-run.\n  5. Run acceptance only against the allowlisted sandbox.\n`);
+}
+async function doctor(args) {
+    const dir = resolve(flag(args, "--dir") ?? ".witnora/design-partner");
+    const report = await runPilotDoctor(dir, await readConfig(dir));
+    process.stdout.write(formatDoctorReport(report));
+    if (!report.ready)
+        throw new Error(`Design-partner doctor found ${report.summary.FAIL + report.summary.NOT_CONFIGURED} unsafe or incomplete condition(s).`);
+}
+async function dryRun(args) {
+    const dir = resolve(flag(args, "--dir") ?? ".witnora/design-partner");
+    const config = await readConfig(dir);
+    const readCredential = requiredEnvironment(config.readCredentialEnv);
+    const targetUrl = flag(args, "--target-url") ?? process.env.WITNORA_TARGET_URL ?? config.targetUrl;
+    const before = await readGitHubTargetState(targetUrl, readCredential);
+    if (before.merged)
+        throw new Error("Dry-run target is already merged; reset the sandbox fixture.");
+    process.stdout.write(`PASS Contract validation\nPASS Canonical target identity preview\nPASS Policy requires exact approval\nPASS Read-only target precondition\nPASS No target write performed\nTarget: ${before.owner}/${before.repository}#${before.pullRequestNumber}\n`);
+}
+async function acceptance(args) {
+    const dir = resolve(flag(args, "--dir") ?? ".witnora/design-partner");
+    const config = await readConfig(dir);
+    const outDir = flag(args, "--out") ?? join(dir, "acceptance");
+    const authorization = await readAuthorization(dir);
+    const outcome = await runDesignPartnerAcceptance({ outDir, attemptStatePath: join(outDir, "gateway-attempt-v0.2.json"), grantClaimDirectory: process.env.WITNORA_GRANT_CLAIM_DIR ?? join(dir, "claims"), targetUrl: flag(args, "--target-url") ?? process.env.WITNORA_TARGET_URL ?? config.targetUrl, probeUrl: flag(args, "--probe-url") ?? process.env.WITNORA_PROBE_URL ?? config.probeUrl, writeCredential: requiredEnvironment(config.writeCredentialEnv), declaredTarget: config.declaredTarget, tenantRef: config.tenantRef, projectRef: config.projectRef, environment: config.environment, trustMaterial: await readGatewayTrustMaterial(dir), authorization, crashAfterTargetSuccess: args.includes("--crash-after-target-success"), crashAfterTargetAcknowledged: args.includes("--crash-after-target-acknowledged"), recoverOnly: args.includes("--recover-only") });
+    const now = new Date().toISOString();
+    await markPilotLifecycle(dir, { firstSignedObservationAt: now, firstTargetDispatchAt: now, ...(outcome.report.overall === "PASS" ? { firstVerifiedOutcomeAt: now } : {}), recoveryRequiredCount: args.includes("--recover-only") ? 1 : 0 });
+    await writePilotAcceptanceReport(dir);
+    process.stdout.write(`PASS 1/5 Approval and one-use Grant validated\nPASS 2/5 Durable dispatch journal written\nPASS 3/5 Target dispatch completed or reconciled\nPASS 4/5 Independent Probe observation received\n${outcome.report.overall === "PASS" ? "PASS" : "FAIL"} 5/5 Evidence Packet verified\nEvidence Packet v0.2: ${outcome.paths.packet}\nOffline verification: ${outcome.report.overall}\nMetrics: ${JSON.stringify(outcome.metrics)}\n`);
+    if (outcome.report.overall !== "PASS")
+        process.exitCode = 1;
+}
+async function prepareLiveGitHub(args) {
+    const dir = resolve(flag(args, "--dir") ?? ".witnora/design-partner");
+    const config = await readConfig(dir);
+    const repository = requiredFlag(args, "--repository");
+    const pullRequestNumber = Number(requiredFlag(args, "--pull-request"));
+    const [owner, name, ...rest] = repository.split("/");
+    if (!owner || !name || rest.length > 0 || !Number.isSafeInteger(pullRequestNumber) || pullRequestNumber < 1) {
+        throw new Error("Live GitHub target must use --repository owner/name and a positive --pull-request number.");
+    }
+    const allowlist = requiredEnvironment("WITNORA_LIVE_GITHUB_ALLOWLIST");
+    const target = { owner, repository: name, pullRequestNumber };
+    const state = await readLiveGitHubPullRequest({
+        ...target,
+        credential: requiredEnvironment(config.readCredentialEnv),
+        requiredChecks: Object.keys(config.declaredTarget.checks),
+        apiBase: flag(args, "--api-base"),
+    });
+    assertLiveGitHubSafety(target, state.baseBranch, allowlist);
+    if (state.merged || !state.open)
+        throw new Error("Live GitHub sandbox pull request must be open and unmerged.");
+    config.declaredTarget = state;
+    await writeFile(join(dir, "design-partner.json"), `${JSON.stringify(config, null, 2)}\n`);
+    const trust = await readGatewayTrustMaterial(dir);
+    const liveProbeConfig = probeConfig(config, trust, "", "./data-live", "../secrets/probe-private.pem");
+    delete liveProbeConfig.githubTarget;
+    liveProbeConfig.githubLive = {
+        apiBase: flag(args, "--api-base") ?? "https://api.github.com",
+        requiredCredentialRef: `env:${config.readCredentialEnv}`,
+    };
+    await writeFile(join(dir, "probe/config.live.json"), `${JSON.stringify(liveProbeConfig, null, 2)}\n`);
+    process.stdout.write(`Prepared live GitHub sandbox ${repository}#${pullRequestNumber}. Review the exact SHAs, then issue fresh authorization before dispatch.\n`);
+}
+async function verifyOffline(args) {
+    const packetPath = flag(args, "--packet") ?? args[1];
+    const rootPath = flag(args, "--root");
+    if (!packetPath || !rootPath || !flag(args, "--revocation-journal"))
+        throw new Error("verify-offline requires --packet, --root, and --revocation-journal from a trusted current source.");
+    const packet = JSON.parse(await readFile(resolve(packetPath), "utf8"));
+    const root = JSON.parse(await readFile(resolve(rootPath), "utf8"));
+    const journalPath = flag(args, "--revocation-journal");
+    const latestJournal = JSON.parse(await readFile(resolve(journalPath), "utf8"));
+    const historicalAt = flag(args, "--historical-at");
+    const report = verifyEvidencePacketV02(packet, root, historicalAt ? new Date(historicalAt) : new Date(), latestJournal);
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    const dir = flag(args, "--dir");
+    if (report.overall === "PASS" && dir) {
+        await markPilotLifecycle(resolve(dir), { firstOfflineVerificationAt: new Date().toISOString() });
+        await writePilotAcceptanceReport(resolve(dir));
+    }
+    if (report.overall !== "PASS")
+        process.exitCode = 1;
+}
+async function inspectPrivacy(args) { const dir = resolve(flag(args, "--dir") ?? ".witnora/design-partner"); const manifest = JSON.parse(await readFile(join(dir, "witnora.privacy-manifest.json"), "utf8")); process.stdout.write(formatPrivacyInspection(manifest, await readConfig(dir))); }
+async function supportBundle(args) { const dir = resolve(flag(args, "--dir") ?? ".witnora/design-partner"); const out = flag(args, "--out"); const result = await collectSupportBundle(dir, await readConfig(dir), out ? resolve(out) : undefined); process.stdout.write(`Support bundle: ${result.bundlePath}\nPrivacy scan: ${result.scanPath}\nRaw secret canary matches: 0\n`); }
+async function pilotReport(args) { const dir = resolve(flag(args, "--dir") ?? ".witnora/design-partner"); process.stdout.write(`${JSON.stringify(await writePilotAcceptanceReport(dir), null, 2)}\n`); }
+async function pilotLifecycle(args) {
+    const dir = resolve(flag(args, "--dir") ?? ".witnora/design-partner");
+    const report = await runPilotLifecycleDemonstration(dir);
+    const stages = report.stages;
+    process.stdout.write(`${stages.map((stage, index) => `${index + 1}/4 ${stage.status.padEnd(30)} ${stage.stage}`).join("\n")}\nReport: ${join(dir, "pilot/lifecycle-demonstration.json")}\n`);
+}
+async function inspectTrust(args) { const dir = resolve(flag(args, "--dir") ?? ".witnora/design-partner"); const trust = await readGatewayTrustMaterial(dir); process.stdout.write(`Pinned root: ${trust.root.rootFingerprint}\nGateway role: ${trust.gatewayCertificate.role}\nProbe role: ${trust.probeCertificate.role}\nRevocation checkpoint: ${trust.journal.checkpointDigest}\n`); }
+async function issueAuthorization(args) {
+    const dir = resolve(flag(args, "--dir") ?? ".witnora/design-partner");
+    const config = await readConfig(dir);
+    const trust = await readAdministrativeTrustMaterial(dir);
+    const identity = createGitHubAcceptanceIdentity(config.declaredTarget, config.targetUrl);
+    const authorization = issueAcceptanceAuthorization(trust, { tenantRef: config.tenantRef, projectRef: config.projectRef, environment: config.environment, actionDigest: githubActionDigest(identity) });
+    await mkdir(join(dir, "authorization"), { recursive: true });
+    await Promise.all([writeFile(join(dir, "authorization/approval.json"), `${JSON.stringify(authorization.approval, null, 2)}\n`), writeFile(join(dir, "authorization/grant.json"), `${JSON.stringify(authorization.grant, null, 2)}\n`)]);
+    await markPilotLifecycle(dir, { firstGrantIssuedAt: new Date().toISOString() });
+    process.stdout.write(`Issued signed approval ${authorization.approval.approvalId} and single-use Grant ${authorization.grant.grantId}. Private issuer keys remain outside Gateway and target runtime mounts.\n`);
+}
+async function revokeProbe(args) {
+    const dir = resolve(flag(args, "--dir") ?? ".witnora/design-partner");
+    const trust = revokeProbeCertificate(await readAdministrativeTrustMaterial(dir), { effectiveAt: flag(args, "--effective-at") ?? new Date().toISOString(), retroactive: args.includes("--retroactive"), reason: flag(args, "--reason") ?? "Customer-operated Probe key revoked." });
+    await writeFile(join(dir, "trust/revocation-journal.json"), `${JSON.stringify(trust.journal, null, 2)}\n`);
+    process.stdout.write(`Revoked Probe certificate ${trust.probeCertificate.certificateId}. New observations at or after the effective time will fail closed.\n`);
+}
+async function rotateProbe(args) {
+    const dir = resolve(flag(args, "--dir") ?? ".witnora/design-partner");
+    const trust = rotateProbeCertificate(await readAdministrativeTrustMaterial(dir));
+    await Promise.all([
+        writeFile(join(dir, "trust/probe-certificate.json"), `${JSON.stringify(trust.probeCertificate, null, 2)}\n`),
+        writeFile(join(dir, "secrets/probe-private.pem"), trust.probePrivateKeyPem),
+    ]);
+    const updateConfig = async (relative) => { const path = join(dir, relative); const value = JSON.parse(await readFile(path, "utf8")); value.probeSigningKey.keyCertificateId = trust.probeCertificate.certificateId; await writeFile(path, `${JSON.stringify(value, null, 2)}\n`); };
+    await Promise.all([updateConfig("probe/config.json"), updateConfig("probe/config.container.json")]);
+    await chmod(join(dir, "secrets/probe-private.pem"), 0o600).catch(() => undefined);
+    process.stdout.write(`Rotated Probe certificate to ${trust.probeCertificate.certificateId}. Restart the Probe before requesting a new observation.\n`);
+}
+async function targetEmulator(args) { const dir = resolve(flag(args, "--dir") ?? ".witnora/design-partner"); const trust = await readAuthorizationTrustMaterial(dir); const config = await readConfig(dir); await startGitHubTargetEmulator({ host: flag(args, "--host"), port: Number(flag(args, "--port") ?? "4311"), statePath: flag(args, "--state") ?? join(dir, "target-state.json"), readCredential: requiredEnvironment("WITNORA_GITHUB_READ_CREDENTIAL"), writeCredential: requiredEnvironment("WITNORA_GITHUB_WRITE_CREDENTIAL"), expectedExecutionBoundaryDigest: executionBoundaryDigest(config.targetUrl), authorizationTrust: trust }); }
+async function readConfig(dir) { const value = JSON.parse(await readFile(join(dir, "design-partner.json"), "utf8")); if (value.protocolVersion !== "witnora.design_partner_github.v0.2")
+    throw new Error("Unsupported design-partner config version."); return value; }
+async function readGatewayTrustMaterial(dir) {
+    const read = async (relative) => JSON.parse(await readFile(join(dir, relative), "utf8"));
+    const requestSignerKeyPath = process.env.WITNORA_REQUEST_SIGNER_PRIVATE_KEY_PATH ?? join(dir, "secrets/request-signer-private.pem");
+    const gatewayKeyPath = process.env.WITNORA_GATEWAY_PRIVATE_KEY_PATH ?? join(dir, "secrets/gateway-private.pem");
+    return { root: await read("trust/pinned-root.json"), requestSignerCertificate: await read("trust/request-signer-certificate.json"), gatewayCertificate: await read("trust/gateway-certificate.json"), probeCertificate: await read("trust/probe-certificate.json"), approvalCertificate: await read("trust/approval-certificate.json"), grantCertificate: await read("trust/grant-certificate.json"), journal: await read("trust/revocation-journal.json"), requestSignerPrivateKeyPem: await readFile(requestSignerKeyPath, "utf8"), gatewayPrivateKeyPem: await readFile(gatewayKeyPath, "utf8") };
+}
+async function readAuthorizationTrustMaterial(dir) {
+    const read = async (relative) => JSON.parse(await readFile(join(dir, relative), "utf8"));
+    return {
+        root: await read("trust/pinned-root.json"),
+        approvalCertificate: await read("trust/approval-certificate.json"),
+        grantCertificate: await read("trust/grant-certificate.json"),
+        journal: await read("trust/revocation-journal.json"),
+    };
+}
+async function readAdministrativeTrustMaterial(dir) {
+    return { ...await readGatewayTrustMaterial(dir), rootPrivateKeyPem: await readFile(join(dir, "secrets/root-private.pem"), "utf8"), probePrivateKeyPem: await readFile(join(dir, "secrets/probe-private.pem"), "utf8"), approvalPrivateKeyPem: await readFile(join(dir, "secrets/approval-private.pem"), "utf8"), grantPrivateKeyPem: await readFile(join(dir, "secrets/grant-private.pem"), "utf8") };
+}
+async function readAuthorization(dir) { return { approval: JSON.parse(await readFile(join(dir, "authorization/approval.json"), "utf8")), grant: JSON.parse(await readFile(join(dir, "authorization/grant.json"), "utf8")) }; }
+function requiredEnvironment(name) { const value = process.env[name]; if (!value)
+    throw new Error(`${name} must be supplied by the customer secret store.`); return value; }
+function flag(args, name) { const index = args.indexOf(name); return index >= 0 ? args[index + 1] : undefined; }
+function requiredFlag(args, name) { const value = flag(args, name); if (!value)
+    throw new Error(`${name} is required.`); return value; }
+function help() { return `Usage:\n  witnora design-partner init github-pr-merge --out ./witnora-pilot\n  witnora design-partner authorization issue --dir ./witnora-pilot\n  witnora design-partner doctor --dir ./witnora-pilot\n  witnora design-partner privacy inspect --dir ./witnora-pilot\n  witnora design-partner collect-support-bundle --dir ./witnora-pilot\n  witnora design-partner pilot-lifecycle --dir ./witnora-pilot\n  witnora design-partner pilot-report --dir ./witnora-pilot\n  witnora design-partner trust inspect --dir ./witnora-pilot\n  witnora design-partner trust revoke-probe [--effective-at <timestamp>]\n  witnora design-partner trust rotate-probe\n  witnora design-partner dry-run --dir ./witnora-pilot --target-url http://127.0.0.1:4311\n  witnora design-partner run-acceptance --dir ./witnora-pilot\n  witnora design-partner recover-acceptance --dir ./witnora-pilot\n  witnora design-partner prepare-live-github --repository owner/sandbox-repo --pull-request 1 (read-only preflight)\n  witnora design-partner verify-offline --packet <path> --root <path> --revocation-journal <latest.json> [--historical-at <timestamp>]\n`; }
+function checklist() { return "# GitHub sandbox acceptance checklist\n\n- [ ] Repository name contains sandbox or test.\n- [ ] Base branch is not main/master.\n- [ ] Agent has no target write credential.\n- [ ] Gateway write and Probe read credentials differ.\n- [ ] Pinned root fingerprint was verified out of band.\n- [ ] Probe and Gateway secret mounts are disjoint.\n- [ ] Dry-run completed without a target write.\n- [ ] Evidence limitations were reviewed.\n"; }
+function probeConfig(config, trust, targetUrl, stateDirectory, privateKeyPemPath) {
+    return {
+        host: "0.0.0.0", port: 4312, stateDirectory, requestBodyLimitBytes: 65_536,
+        observationTimeoutMs: 5_000, shutdownTimeoutMs: 10_000,
+        retry: { maxAttempts: 4, baseDelayMs: 250, scanIntervalMs: 500 },
+        bindings: { tenantRef: config.tenantRef, projectRef: config.projectRef, environment: config.environment, probeId: "customer-github-probe" },
+        requestVerificationKeys: [{ keyId: trust.requestSignerCertificate.subjectKeyId, publicKeyPemPath: "./request-signer-public.pem", role: "probe_observation_request_signer", validFrom: trust.requestSignerCertificate.notBefore, validUntil: trust.requestSignerCertificate.notAfter }],
+        probeSigningKey: { keyCertificateId: trust.probeCertificate.certificateId, privateKeyPemPath },
+        probeVersion: "0.2.0", storageEncryptionKeyEnv: "WITNORA_PROBE_STORAGE_KEY_BASE64",
+        githubTarget: { url: targetUrl, requiredCredentialRef: `env:${config.readCredentialEnv}` },
+    };
+}
+function baseDesignPartnerCompose() {
+    return `services:
+  target-data-init:
+    image: node:22-alpine
+    user: "0:0"
+    read_only: true
+    network_mode: none
+    tmpfs: ["/tmp:rw,noexec,nosuid,size=4m"]
+    command: ["sh", "-eu", "-c", "if [ ! -f /state/target-state.json ]; then cp /seed/target-state.json /state/target-state.json; fi; chown -R 10001:10001 /state; chmod 0700 /state; chmod 0600 /state/target-state.json"]
+    volumes:
+      - ./target-state.json:/seed/target-state.json:ro
+      - target-data:/state
+  target-sandbox:
+    build:
+      context: \${WITNORA_SOURCE_ROOT:-../..}/packages/witnora-cli
+      dockerfile: Dockerfile.design-partner
+    entrypoint: ["/bin/sh", "-c"]
+    command: ["exec node /app/dist/cli.js design-partner target-emulator --state /state/target-state.json --port 4311"]
+    user: "10001:10001"
+    read_only: true
+    tmpfs: ["/tmp:rw,noexec,nosuid,size=16m"]
+    volumes:
+      - ./target-state.json:/seed/target-state.json:ro
+      - ./design-partner.json:/kit/design-partner.json:ro
+      - ./trust:/kit/trust:ro
+      - target-data:/state
+    environment:
+      WITNORA_GITHUB_READ_CREDENTIAL: \${WITNORA_GITHUB_READ_CREDENTIAL:?set a read-only sandbox credential}
+      WITNORA_GITHUB_WRITE_CREDENTIAL: \${WITNORA_GITHUB_WRITE_CREDENTIAL:?set a distinct write sandbox credential}
+    ports: ["127.0.0.1:4311:4311"]
+    networks: [read-path, write-path]
+    depends_on:
+      target-data-init:
+        condition: service_completed_successfully
+  probe-data-init:
+    image: node:22-alpine
+    user: "0:0"
+    read_only: true
+    network_mode: none
+    tmpfs: ["/tmp:rw,noexec,nosuid,size=4m"]
+    command: ["sh", "-eu", "-c", "chown -R 10001:10001 /data; chmod 0700 /data"]
+    volumes:
+      - probe-data:/data
+  probe-key-init:
+    image: node:22-alpine
+    user: "0:0"
+    read_only: true
+    network_mode: none
+    tmpfs: ["/tmp:rw,noexec,nosuid,size=4m"]
+    command: ["sh", "-eu", "-c", "umask 077; cp /run/secrets/probe-private.pem /keys/probe-private.pem; chown 10001:10001 /keys/probe-private.pem; chmod 0400 /keys/probe-private.pem"]
+    volumes:
+      - probe-key-data:/keys
+    secrets:
+      - source: probe_signing_key
+        target: probe-private.pem
+  probe:
+    build:
+      context: \${WITNORA_SOURCE_ROOT:-../..}/packages/witnora-probe
+    command: ["node", "dist/cli.js"]
+    user: "10001:10001"
+    read_only: true
+    tmpfs: ["/tmp:rw,noexec,nosuid,size=16m"]
+    volumes:
+      - ./probe/config.container.json:/kit/probe/config.container.json:ro
+      - ./probe/request-signer-public.pem:/kit/probe/request-signer-public.pem:ro
+      - probe-data:/app/data
+      - probe-key-data:/app/keys:ro
+    environment:
+      WITNORA_PROBE_CONFIG: /kit/probe/config.container.json
+      WITNORA_PROBE_STORAGE_KEY_BASE64: \${WITNORA_PROBE_STORAGE_KEY_BASE64:?set a base64 32-byte local storage key}
+      WITNORA_GITHUB_READ_CREDENTIAL: \${WITNORA_GITHUB_READ_CREDENTIAL:?set a read-only sandbox credential}
+    ports: ["127.0.0.1:4312:4312"]
+    networks: [read-path]
+    depends_on:
+      target-sandbox:
+        condition: service_started
+      probe-data-init:
+        condition: service_completed_successfully
+      probe-key-init:
+        condition: service_completed_successfully
+  gateway-key-init:
+    profiles: ["acceptance"]
+    image: node:22-alpine
+    user: "0:0"
+    read_only: true
+    network_mode: none
+    tmpfs: ["/tmp:rw,noexec,nosuid,size=4m"]
+    command: ["sh", "-eu", "-c", "umask 077; cp /run/secrets/request-signer-private.pem /keys/request-signer-private.pem; cp /run/secrets/gateway-private.pem /keys/gateway-private.pem; chown 10001:10001 /keys/*.pem; chmod 0400 /keys/*.pem"]
+    volumes:
+      - gateway-key-data:/keys
+    secrets:
+      - source: request_signing_key
+        target: request-signer-private.pem
+      - source: gateway_signing_key
+        target: gateway-private.pem
+  acceptance-output-init:
+    profiles: ["acceptance"]
+    image: node:22-alpine
+    user: "0:0"
+    read_only: true
+    network_mode: none
+    tmpfs: ["/tmp:rw,noexec,nosuid,size=4m"]
+    command: ["sh", "-eu", "-c", "chown -R 10001:10001 /output /claims /pilot; chmod 0700 /output /claims /pilot"]
+    volumes:
+      - ./acceptance:/output
+      - ./claims:/claims
+      - ./pilot:/pilot
+  gateway-acceptance:
+    profiles: ["acceptance"]
+    build:
+      context: \${WITNORA_SOURCE_ROOT:-../..}/packages/witnora-cli
+      dockerfile: Dockerfile.design-partner
+    command: ["design-partner", "run-acceptance", "--dir", "/kit", "--out", "/output", "--target-url", "http://target-sandbox:4311", "--probe-url", "http://probe:4312"]
+    user: "10001:10001"
+    read_only: true
+    tmpfs: ["/tmp:rw,noexec,nosuid,size=16m"]
+    volumes:
+      - ./design-partner.json:/kit/design-partner.json:ro
+      - ./trust:/kit/trust:ro
+      - ./authorization:/kit/authorization:ro
+      - ./pilot:/kit/pilot
+      - gateway-key-data:/app/keys:ro
+      - acceptance-data:/output
+      - ./claims:/claims
+    environment:
+      WITNORA_REQUEST_SIGNER_PRIVATE_KEY_PATH: /app/keys/request-signer-private.pem
+      WITNORA_GATEWAY_PRIVATE_KEY_PATH: /app/keys/gateway-private.pem
+      WITNORA_GRANT_CLAIM_DIR: /claims
+      WITNORA_GITHUB_WRITE_CREDENTIAL: \${WITNORA_GITHUB_WRITE_CREDENTIAL:?set a sandbox write credential}
+    networks: [read-path, write-path]
+    depends_on:
+      target-sandbox:
+        condition: service_started
+      probe:
+        condition: service_started
+      gateway-key-init:
+        condition: service_completed_successfully
+      acceptance-output-init:
+        condition: service_completed_successfully
+  offline-verifier:
+    profiles: ["acceptance"]
+    build:
+      context: \${WITNORA_SOURCE_ROOT:-../..}/packages/witnora-cli
+      dockerfile: Dockerfile.design-partner
+    command: ["design-partner", "verify-offline", "--packet", "/output/witnora-evidence-packet-v0.2.json", "--root", "/trust/pinned-root.json", "--revocation-journal", "/trust/revocation-journal.json"]
+    user: "10001:10001"
+    read_only: true
+    tmpfs: ["/tmp:rw,noexec,nosuid,size=16m"]
+    volumes:
+      - ./trust:/trust:ro
+      - acceptance-data:/output:ro
+    network_mode: none
+volumes:
+  target-data: {}
+  probe-data: {}
+  probe-key-data: {}
+  gateway-key-data: {}
+  acceptance-data: {}
+secrets:
+  probe_signing_key:
+    file: ./secrets/probe-private.pem
+  request_signing_key:
+    file: ./secrets/request-signer-private.pem
+  gateway_signing_key:
+    file: ./secrets/gateway-private.pem
+networks:
+  write-path: {}
+  read-path: {}
+`;
+}

package/dist/evidence-v02.js

@@ -0,0 +1,118 @@
+import { createPublicKey, verify } from "node:crypto";
+import { canonicalBytesV02, sha256CanonicalV02 } from "./canonical-v02.js";
+import { verifyAuthorizationV02 } from "./authorization-v02.js";
+import { verifyProbeAttestation, verifyProbeRequest } from "./probe-protocol-v02.js";
+import { assertNotRevoked, assertRevocationJournalExtends, verifyKeyCertificate, verifyRevocationJournal } from "./trust-v02.js";
+export function gatewaySignedValue(packet) {
+    const { gatewaySignature: _signature, ...value } = packet;
+    return value;
+}
+export function verifyEvidencePacketV02(packet, pinnedRoot, verificationTime = new Date(), latestRevocationJournal) {
+    const failures = [];
+    if (!packet || typeof packet !== "object" || packet.protocolVersion !== "witnora.verifiable_evidence_packet.v0.2"
+        || !packet.approval || !packet.grant || !packet.executionAttempt || !packet.reconciliation || !packet.probeRequest
+        || !packet.probeAttestation || !packet.trust || !packet.separation || !packet.privacy || !packet.evidenceStrength || !packet.gatewaySignature) {
+        return failedReport("Evidence packet v0.2 is structurally incomplete.");
+    }
+    let crypto = true;
+    try {
+        if (packet.protocolVersion !== "witnora.verifiable_evidence_packet.v0.2")
+            throw new Error("Unsupported evidence protocol version.");
+        if (packet.trust.rootId !== pinnedRoot.rootId)
+            throw new Error("Packet does not reference the pinned root.");
+        if (!latestRevocationJournal)
+            throw new Error("Latest trusted revocation journal is required; packet-embedded trust state cannot establish current verification.");
+        const journal = latestRevocationJournal;
+        verifyRevocationJournal(journal, pinnedRoot);
+        verifyRevocationJournal(packet.trust.revocationJournal, pinnedRoot);
+        assertRevocationJournalExtends(packet.trust.revocationJournal, journal);
+        const requestedAt = new Date(packet.probeRequest.requestedAt);
+        verifyKeyCertificate(packet.trust.requestSignerCertificate, pinnedRoot, requestedAt, { role: "server_attestor", tenantRef: packet.tenantRef, projectRef: packet.projectRef, environment: packet.environment });
+        assertNotRevoked(packet.trust.requestSignerCertificate, journal, requestedAt);
+        if (packet.probeRequest.requestSignerKeyId !== packet.trust.requestSignerCertificate.subjectKeyId)
+            throw new Error("Probe request signer certificate ID mismatch.");
+        const observedAt = new Date(packet.probeAttestation.observedAt);
+        const eventVerificationTime = verificationTime;
+        verifyProbeRequest(packet.probeRequest, packet.trust.requestSignerCertificate.publicKeyPem, {
+            tenantRef: packet.tenantRef, projectRef: packet.projectRef, environment: packet.environment,
+            actionDigest: packet.actionDigest, contractDigest: packet.contractDigest, resourceCommitment: packet.resourceCommitment,
+            predicateDigest: packet.predicateDigest, probeId: packet.probeAttestation.probeId, now: observedAt,
+        });
+        const issuedAt = new Date(packet.issuedAt);
+        verifyKeyCertificate(packet.trust.gatewayCertificate, pinnedRoot, issuedAt, { role: "gateway_runtime", tenantRef: packet.tenantRef, projectRef: packet.projectRef, environment: packet.environment });
+        assertNotRevoked(packet.trust.gatewayCertificate, journal, issuedAt);
+        if (packet.gatewaySignature.keyId !== packet.trust.gatewayCertificate.subjectKeyId || !verify(null, canonicalBytesV02(gatewaySignedValue(packet)), createPublicKey(packet.trust.gatewayCertificate.publicKeyPem), Buffer.from(packet.gatewaySignature.signature, "base64")))
+            throw new Error("Gateway packet signature is invalid.");
+        verifyAuthorizationV02({ approval: packet.approval, grant: packet.grant, trust: { root: pinnedRoot, approvalCertificate: packet.trust.approvalCertificate, grantCertificate: packet.trust.grantCertificate, revocationJournal: journal }, expected: { tenantRef: packet.tenantRef, projectRef: packet.projectRef, environment: packet.environment, actionDigest: packet.actionDigest }, at: issuedAt });
+        verifyProbeAttestation(packet.probeAttestation, packet.probeRequest, { root: pinnedRoot, certificate: packet.trust.probeCertificate, revocationJournal: journal }, {
+            tenantRef: packet.tenantRef, projectRef: packet.projectRef, environment: packet.environment,
+            actionDigest: packet.actionDigest, contractDigest: packet.contractDigest, resourceCommitment: packet.resourceCommitment,
+            predicateDigest: packet.predicateDigest, probeId: packet.probeAttestation.probeId, now: eventVerificationTime, maxFreshnessMs: 300_000,
+        });
+        if (packet.probeAttestation.probeId !== packet.trust.probeCertificate.operatorIdentity)
+            throw new Error("Probe identity is not bound to the certified operator identity.");
+    }
+    catch (error) {
+        crypto = false;
+        failures.push(error instanceof Error ? error.message : String(error));
+    }
+    const terminalState = packet.executionAttempt.state === "RECONCILED_SUCCESS";
+    const recoveryChainValid = sha256CanonicalV02(packet.executionAttempt.recoveryHistory) === packet.eventChainDigest && packet.executionAttempt.recoveryHistory.at(-1)?.state === packet.executionAttempt.state;
+    const dispatchReconciled = packet.executionAttempt.dispatchCount === 1 && terminalState && recoveryChainValid && packet.reconciliation.status === "TARGET_STATE_RECONCILED";
+    const grantUseBound = packet.reconciliation.authorizationBindingSource === "TARGET_GRANT_ECHO"
+        ? packet.probeAttestation.normalizedObservation.consumedGrantId === packet.grant.grantId
+        : packet.reconciliation.authorizationBindingSource === "GATEWAY_DISPATCH_RECORD" && dispatchReconciled;
+    const authorizationBound = crypto && packet.approval.actionDigest === packet.actionDigest && packet.grant.actionDigest === packet.actionDigest && packet.grant.maxUses === 1 && grantUseBound;
+    const outcomeObserved = packet.probeAttestation.outcomeStatus === "VERIFIED" && dispatchReconciled;
+    const customerOperated = ["separate_process", "separate_container", "customer_network"].includes(packet.separation.probeDeploymentMode)
+        && pinnedRoot.ownerType === "CUSTOMER_ASSURANCE_ROOT"
+        && packet.evidenceStrength.outcomeObservation === "CUSTOMER_OPERATED_READ_PATH";
+    const expectedSeparation = packet.separation.probeDeploymentMode === "customer_network"
+        ? "CUSTOMER_NETWORK_SEPARATED"
+        : packet.separation.probeDeploymentMode === "separate_container" ? "CONTAINER_SEPARATED" : "PROCESS_SEPARATED";
+    const expectedAuthorizationStrength = authorizationBound
+        ? packet.reconciliation.authorizationBindingSource === "TARGET_GRANT_ECHO" ? "EXACT_ACTION_GRANT_BOUND" : "GATEWAY_DISPATCH_BOUND"
+        : "NOT_ESTABLISHED";
+    const strengthConsistent = packet.evidenceStrength.authorizationBinding === expectedAuthorizationStrength
+        && packet.evidenceStrength.executionBinding === (dispatchReconciled ? "TARGET_STATE_RECONCILED" : packet.executionAttempt.state === "DISPATCH_UNKNOWN" ? "DISPATCH_UNKNOWN" : "NOT_ESTABLISHED")
+        && packet.evidenceStrength.sourceIntegrity === (crypto ? "CUSTOMER_ROOT_CERTIFIED" : "SELF_ASSERTED")
+        && packet.evidenceStrength.outcomeObservation === (outcomeObserved ? "CUSTOMER_OPERATED_READ_PATH" : "NOT_OBSERVED")
+        && packet.evidenceStrength.operatorSeparation === expectedSeparation
+        && packet.evidenceStrength.review !== "EXTERNAL"
+        && packet.privacy.rawCanaryMatchesOutsideLocal === 0;
+    if (!authorizationBound)
+        failures.push("Authorization is not bound to the exact action.");
+    if (!dispatchReconciled)
+        failures.push("Target dispatch is not reconciled.");
+    if (!outcomeObserved)
+        failures.push("Outcome was not independently observed.");
+    if (!recoveryChainValid)
+        failures.push("Execution recovery history is incomplete or does not match its digest.");
+    if (!strengthConsistent)
+        failures.push("Evidence-strength vector overclaims the packet evidence.");
+    if (sha256CanonicalV02(packet.probeRequest) !== packet.probeAttestation.requestDigest)
+        failures.push("Probe request digest mismatch.");
+    return {
+        protocolVersion: "witnora.offline_verification_report.v0.2",
+        overall: crypto && authorizationBound && dispatchReconciled && outcomeObserved && customerOperated && strengthConsistent && recoveryChainValid ? "PASS" : "FAIL",
+        networkUsed: false,
+        dimensions: {
+            cryptographicallyValid: crypto,
+            trustedByPinnedRoot: crypto,
+            authorizationBound,
+            dispatchReconciled,
+            outcomeObserved,
+            customerOperated,
+            // v0.2 has no independent reviewer signature object, so this claim cannot be established from the packet.
+            thirdPartyReviewed: false,
+        },
+        failures,
+    };
+}
+function failedReport(message) {
+    return {
+        protocolVersion: "witnora.offline_verification_report.v0.2", overall: "FAIL", networkUsed: false,
+        dimensions: { cryptographicallyValid: false, trustedByPinnedRoot: false, authorizationBound: false, dispatchReconciled: false, outcomeObserved: false, customerOperated: false, thirdPartyReviewed: false },
+        failures: [message],
+    };
+}