witnora 0.10.0 → 0.10.2

package/dist/authorization-state-machine.js

@@ -0,0 +1,35 @@
+export function decideCoveredDispatch(grant, request) {
+    if (!grant)
+        return denied("GRANT_MISSING");
+    if (grant.status === "REVOKED")
+        return denied("GRANT_REVOKED");
+    if (grant.status === "CONSUMED")
+        return denied("GRANT_ALREADY_CONSUMED");
+    if (request.incidentSuspended)
+        return denied("INCIDENT_SUSPENDED");
+    const now = Date.parse(request.now);
+    const notBefore = Date.parse(grant.notBefore);
+    const expiresAt = Date.parse(grant.expiresAt);
+    if (![now, notBefore, expiresAt].every(Number.isFinite) || notBefore >= expiresAt)
+        return denied("INVALID_TIME");
+    if (now < notBefore)
+        return denied("GRANT_NOT_YET_VALID");
+    if (now >= expiresAt)
+        return denied("GRANT_EXPIRED");
+    if (request.tenantRef !== grant.tenantRef)
+        return denied("TENANT_MISMATCH");
+    if (request.agentRef !== grant.agentRef)
+        return denied("AGENT_MISMATCH");
+    if (request.environment !== grant.environment)
+        return denied("ENVIRONMENT_MISMATCH");
+    if (request.policyRef !== grant.policyRef)
+        return denied("POLICY_VERSION_MISMATCH");
+    if (request.contractDigest !== grant.contractDigest)
+        return denied("CONTRACT_VERSION_MISMATCH");
+    if (request.actionDigest !== grant.actionDigest)
+        return denied("ACTION_DIGEST_MISMATCH");
+    return { allowed: true };
+}
+function denied(code) {
+    return { allowed: false, code };
+}

package/dist/authorization-v02.js

@@ -0,0 +1,60 @@
+import { createPrivateKey, createPublicKey, randomBytes, randomUUID, sign, verify } from "node:crypto";
+import { canonicalBytesV02, sha256CanonicalV02 } from "./canonical-v02.js";
+import { assertNotRevoked, verifyKeyCertificate } from "./trust-v02.js";
+export function signApprovalV02(input, privateKeyPem) {
+    const unsigned = { ...input, approvalId: input.approvalId ?? randomUUID(), protocolVersion: "witnora.signed_action_approval.v0.2" };
+    return { ...unsigned, signature: sign(null, canonicalBytesV02(unsigned), createPrivateKey(privateKeyPem)).toString("base64") };
+}
+export function signExecutionGrantV02(input, privateKeyPem) {
+    const unsigned = { ...input, grantId: input.grantId ?? randomUUID(), nonce: input.nonce ?? randomBytes(24).toString("hex"), protocolVersion: "witnora.signed_execution_grant.v0.2" };
+    return { ...unsigned, signature: sign(null, canonicalBytesV02(unsigned), createPrivateKey(privateKeyPem)).toString("base64") };
+}
+export function approvalDigestV02(approval) { return sha256CanonicalV02(approval); }
+export function verifyAuthorizationV02(input) {
+    const { approval, grant, trust, expected } = input;
+    const at = input.at ?? new Date();
+    if (approval.protocolVersion !== "witnora.signed_action_approval.v0.2" || grant.protocolVersion !== "witnora.signed_execution_grant.v0.2")
+        throw new Error("Unsupported signed authorization protocol.");
+    verifyKeyCertificate(trust.approvalCertificate, trust.root, new Date(approval.approvedAt), { role: "reviewer", tenantRef: expected.tenantRef, projectRef: expected.projectRef, environment: expected.environment });
+    verifyKeyCertificate(trust.grantCertificate, trust.root, new Date(grant.issuedAt), { role: "resource_scope_evaluator", tenantRef: expected.tenantRef, projectRef: expected.projectRef, environment: expected.environment });
+    assertNotRevoked(trust.approvalCertificate, trust.revocationJournal, new Date(approval.approvedAt));
+    assertNotRevoked(trust.grantCertificate, trust.revocationJournal, new Date(grant.issuedAt));
+    verifySignedApproval(approval, trust.approvalCertificate);
+    verifySignedGrant(grant, trust.grantCertificate);
+    for (const value of [approval, grant]) {
+        if (value.tenantRef !== expected.tenantRef || value.projectRef !== expected.projectRef || value.environment !== expected.environment || value.actionDigest !== expected.actionDigest)
+            throw new Error("Signed authorization scope or exact-action binding mismatch.");
+    }
+    if (grant.approvalDigest !== approvalDigestV02(approval))
+        throw new Error("Execution Grant is not bound to the signed approval.");
+    if (grant.maxUses !== 1)
+        throw new Error("Execution Grant must be single-use.");
+    const now = at.getTime();
+    const notBefore = parseInstant(grant.notBefore, "grant notBefore");
+    const grantExpiry = parseInstant(grant.expiresAt, "grant expiresAt");
+    const approvalExpiry = parseInstant(approval.expiresAt, "approval expiresAt");
+    if (now < notBefore || now > grantExpiry || now > approvalExpiry)
+        throw new Error("Signed authorization is not currently valid.");
+}
+function verifySignedApproval(value, certificate) {
+    if (value.signerKeyId !== certificate.subjectKeyId)
+        throw new Error("Signed approval key ID does not match its certificate.");
+    const { signature, ...unsigned } = value;
+    if (!verify(null, canonicalBytesV02(unsigned), createPublicKey(certificate.publicKeyPem), Buffer.from(signature, "base64")))
+        throw new Error("Signed approval signature is invalid.");
+}
+function verifySignedGrant(value, certificate) {
+    if (value.issuerKeyId !== certificate.subjectKeyId)
+        throw new Error("Signed execution Grant key ID does not match its certificate.");
+    const { signature, ...unsigned } = value;
+    if (!verify(null, canonicalBytesV02(unsigned), createPublicKey(certificate.publicKeyPem), Buffer.from(signature, "base64")))
+        throw new Error("Signed execution Grant signature is invalid.");
+}
+function parseInstant(value, field) {
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/.test(value))
+        throw new Error(`${field} must be an RFC 3339 UTC timestamp with at most millisecond precision.`);
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed))
+        throw new Error(`${field} is invalid.`);
+    return parsed;
+}

package/dist/canonical-v02.js

@@ -0,0 +1,197 @@
+import { createHash } from "node:crypto";
+export const WITNORA_CANONICALIZATION_V02 = "witnora.canonical_json.v0.2";
+const MAX_DEPTH = 64;
+/** Strict v0.2 profile: JSON only, safe integers only, no duplicate keys or negative zero. */
+export function canonicalJsonV02(value) {
+    return JSON.stringify(canonicalValueV02(value, "$", 0));
+}
+export function canonicalBytesV02(value) {
+    return Buffer.from(canonicalJsonV02(value), "utf8");
+}
+export function sha256CanonicalV02(value) {
+    return createHash("sha256").update(canonicalBytesV02(value)).digest("hex");
+}
+export function parseStrictJsonV02(input) {
+    const parser = new StrictJsonParser(input);
+    const value = parser.parseValue(0);
+    parser.skipWhitespace();
+    if (!parser.done())
+        throw new Error(`Unexpected token at offset ${parser.offset()}.`);
+    return canonicalValueV02(value, "$", 0);
+}
+function canonicalValueV02(value, path, depth) {
+    if (depth > MAX_DEPTH)
+        throw new Error(`${path} exceeds the v0.2 nesting limit of ${MAX_DEPTH}.`);
+    if (value === null || typeof value === "boolean")
+        return value;
+    if (typeof value === "string") {
+        assertValidUnicode(value, path);
+        return value;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new Error(`${path} contains a non-finite number.`);
+        if (Object.is(value, -0))
+            throw new Error(`${path} contains negative zero.`);
+        if (!Number.isSafeInteger(value))
+            throw new Error(`${path} must be a safe integer; encode decimals as normalized strings.`);
+        return value;
+    }
+    if (Array.isArray(value))
+        return value.map((entry, index) => canonicalValueV02(entry, `${path}[${index}]`, depth + 1));
+    if (value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+        const source = value;
+        const output = {};
+        for (const key of Object.keys(source).sort()) {
+            assertValidUnicode(key, `${path} key`);
+            if (source[key] === undefined)
+                throw new Error(`${path}.${key} is undefined.`);
+            output[key] = canonicalValueV02(source[key], `${path}.${key}`, depth + 1);
+        }
+        return output;
+    }
+    throw new Error(`${path} contains unsupported ${typeof value}.`);
+}
+class StrictJsonParser {
+    source;
+    index = 0;
+    constructor(source) {
+        this.source = source;
+    }
+    offset() { return this.index; }
+    done() { return this.index >= this.source.length; }
+    skipWhitespace() { while (/\s/u.test(this.source[this.index] ?? ""))
+        this.index += 1; }
+    parseValue(depth) {
+        if (depth > MAX_DEPTH)
+            throw new Error(`JSON exceeds the v0.2 nesting limit of ${MAX_DEPTH}.`);
+        this.skipWhitespace();
+        const token = this.source[this.index];
+        if (token === "{")
+            return this.parseObject(depth + 1);
+        if (token === "[")
+            return this.parseArray(depth + 1);
+        if (token === '"')
+            return this.parseString();
+        if (token === "t" && this.consume("true"))
+            return true;
+        if (token === "f" && this.consume("false"))
+            return false;
+        if (token === "n" && this.consume("null"))
+            return null;
+        if (token === "-" || /[0-9]/u.test(token ?? ""))
+            return this.parseNumber();
+        throw new Error(`Invalid JSON value at offset ${this.index}.`);
+    }
+    parseObject(depth) {
+        this.expect("{");
+        this.skipWhitespace();
+        const output = {};
+        const seen = new Set();
+        if (this.peek("}")) {
+            this.index += 1;
+            return output;
+        }
+        while (true) {
+            this.skipWhitespace();
+            const key = this.parseString();
+            if (seen.has(key))
+                throw new Error(`Duplicate JSON object key ${JSON.stringify(key)}.`);
+            seen.add(key);
+            this.skipWhitespace();
+            this.expect(":");
+            output[key] = this.parseValue(depth);
+            this.skipWhitespace();
+            if (this.peek("}")) {
+                this.index += 1;
+                return output;
+            }
+            this.expect(",");
+        }
+    }
+    parseArray(depth) {
+        this.expect("[");
+        this.skipWhitespace();
+        const output = [];
+        if (this.peek("]")) {
+            this.index += 1;
+            return output;
+        }
+        while (true) {
+            output.push(this.parseValue(depth));
+            this.skipWhitespace();
+            if (this.peek("]")) {
+                this.index += 1;
+                return output;
+            }
+            this.expect(",");
+        }
+    }
+    parseString() {
+        const start = this.index;
+        this.expect('"');
+        let escaped = false;
+        while (!this.done()) {
+            const char = this.source[this.index++];
+            if (!escaped && char === '"') {
+                const token = this.source.slice(start, this.index);
+                try {
+                    const value = JSON.parse(token);
+                    assertValidUnicode(value, `JSON string at offset ${start}`);
+                    return value;
+                }
+                catch {
+                    throw new Error(`Invalid JSON string at offset ${start}.`);
+                }
+            }
+            if (!escaped && char === "\\")
+                escaped = true;
+            else
+                escaped = false;
+            if ((char?.charCodeAt(0) ?? 32) < 32)
+                throw new Error(`Unescaped control character at offset ${this.index - 1}.`);
+        }
+        throw new Error(`Unterminated JSON string at offset ${start}.`);
+    }
+    parseNumber() {
+        const rest = this.source.slice(this.index);
+        const match = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u.exec(rest);
+        if (!match)
+            throw new Error(`Invalid JSON number at offset ${this.index}.`);
+        this.index += match[0].length;
+        const value = Number(match[0]);
+        if (!Number.isFinite(value))
+            throw new Error("Non-finite JSON number is not supported.");
+        if (Object.is(value, -0))
+            throw new Error("Negative zero is not supported.");
+        if (!Number.isSafeInteger(value))
+            throw new Error("Only safe integer JSON numbers are supported; use normalized decimal strings.");
+        return value;
+    }
+    consume(value) {
+        if (!this.source.startsWith(value, this.index))
+            return false;
+        this.index += value.length;
+        return true;
+    }
+    peek(value) { return this.source[this.index] === value; }
+    expect(value) {
+        if (!this.peek(value))
+            throw new Error(`Expected ${JSON.stringify(value)} at offset ${this.index}.`);
+        this.index += 1;
+    }
+}
+function assertValidUnicode(value, path) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (!(next >= 0xdc00 && next <= 0xdfff))
+                throw new Error(`${path} contains an unpaired Unicode surrogate.`);
+            index += 1;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            throw new Error(`${path} contains an unpaired Unicode surrogate.`);
+        }
+    }
+}

package/dist/canonical.js

@@ -0,0 +1,31 @@
+import { createHash } from "node:crypto";
+export const WITNORA_CANONICALIZATION_VERSION = "witnora.canonical_json.v0.1";
+/** Stable JSON used by v0.1 digests. Arrays remain ordered; undefined is rejected. */
+export function canonicalJson(value) {
+    return JSON.stringify(canonicalValue(value, "$"));
+}
+export function sha256Canonical(value) {
+    return createHash("sha256").update(canonicalJson(value), "utf8").digest("hex");
+}
+function canonicalValue(value, path) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new Error(`${path} contains a non-finite number.`);
+        return Object.is(value, -0) ? 0 : value;
+    }
+    if (Array.isArray(value))
+        return value.map((item, index) => canonicalValue(item, `${path}[${index}]`));
+    if (value && typeof value === "object") {
+        const source = value;
+        const output = {};
+        for (const key of Object.keys(source).sort()) {
+            if (source[key] === undefined)
+                throw new Error(`${path}.${key} is undefined; canonical input must be explicit.`);
+            output[key] = canonicalValue(source[key], `${path}.${key}`);
+        }
+        return output;
+    }
+    throw new Error(`${path} contains unsupported ${typeof value}.`);
+}

package/dist/cli.js

@@ -29,6 +29,14 @@ import { parseAgentTemplate, starterAdapter, starterGitHubActionWorkflow, starte
 import { renderTrySummary, writeTryEvidence } from "./try.js";
 import { applyGuidedSetup } from "./guided-setup.js";
 import { resolveRuntimeContext } from "./runtime-context.js";
+import { compileAssuranceContract, diffAssuranceContracts, exampleAssuranceContract, readAssuranceContract, renderContractExplanation, } from "./assurance-contract.js";
+import { examplePrivacyManifest, inspectPrivacy } from "./privacy-manifest.js";
+import { renderOfflineVerification, verifyEvidencePacket } from "./offline-verifier.js";
+import { runAssuranceLoopDemo } from "./assurance-loop-demo.js";
+import { importGenericEval, renderGenericEvalReport } from "./generic-eval.js";
+import { runDesignPartnerCommand } from "./design-partner-v02.js";
+import { runOnboard } from "./onboard.js";
+import { verifyEvidencePacketV02 } from "./evidence-v02.js";
 process.on("uncaughtException", reportFatalError);
 process.on("unhandledRejection", reportFatalError);
 const command = process.argv[2] ?? "help";
@@ -38,6 +46,115 @@ const commandHelp = process.argv.some((argument) => argument === "--help" || arg
 if (commandHelp) {
     process.stdout.write(commandHelp);
 }
+else if (command === "contract") {
+    const action = process.argv[3] ?? "help";
+    if (action === "init") {
+        const out = resolve(readFlag("--out") ?? "witnora.assurance-contract.json");
+        await writeStarterFile(out, `${JSON.stringify(exampleAssuranceContract(), null, 2)}\n`, readBoolFlag("--force"));
+        process.stdout.write(`Wrote ${out}\n`);
+    }
+    else if (action === "validate" || action === "explain") {
+        const path = readFlag("--contract") ?? process.argv[4];
+        if (!path)
+            throw new Error("A contract path is required.");
+        process.stdout.write(renderContractExplanation(await readAssuranceContract(path)));
+    }
+    else if (action === "compile") {
+        const path = readFlag("--contract") ?? process.argv[4];
+        if (!path)
+            throw new Error("A contract path is required.");
+        const out = resolve(readFlag("--out") ?? ".witnora/contract/compiled-contract.json");
+        await mkdir(dirname(out), { recursive: true });
+        await writeFile(out, `${JSON.stringify(compileAssuranceContract(await readAssuranceContract(path)), null, 2)}\n`);
+        process.stdout.write(`Wrote deterministic compiler output ${out}\n`);
+    }
+    else if (action === "diff") {
+        const previous = readFlag("--from");
+        const next = readFlag("--to");
+        if (!previous || !next)
+            throw new Error("Contract diff requires --from <contract> and --to <contract>.");
+        process.stdout.write(`${JSON.stringify(diffAssuranceContracts(await readAssuranceContract(previous), await readAssuranceContract(next)), null, 2)}\n`);
+    }
+    else {
+        throw new Error("Use witnora contract init|validate|compile|diff|explain.");
+    }
+}
+else if (command === "privacy") {
+    const action = process.argv[3] ?? "help";
+    if (action === "init") {
+        const out = resolve(readFlag("--out") ?? "witnora.privacy-manifest.json");
+        await writeStarterFile(out, `${JSON.stringify(examplePrivacyManifest(), null, 2)}\n`, readBoolFlag("--force"));
+        process.stdout.write(`Wrote ${out}\n`);
+    }
+    else if (action === "inspect") {
+        const path = readFlag("--manifest") ?? process.argv[4];
+        if (!path)
+            throw new Error("A Privacy Manifest path is required.");
+        process.stdout.write(inspectPrivacy(await readJson(path)));
+    }
+    else {
+        throw new Error("Use witnora privacy init|inspect.");
+    }
+}
+else if (command === "design-partner") {
+    await runDesignPartnerCommand(process.argv.slice(3));
+}
+else if (command === "verify") {
+    const path = readFlag("--offline") ?? readFlag("--packet") ?? process.argv[3];
+    if (!path || path.startsWith("--"))
+        throw new Error("Use witnora verify --offline <packet.json>.");
+    const trustPath = readFlag("--trust");
+    const packet = await readJson(path);
+    if (packet.protocolVersion === "witnora.verifiable_evidence_packet.v0.2") {
+        const revocationPath = readFlag("--revocation-journal");
+        if (!trustPath || !revocationPath)
+            throw new Error("Evidence v0.2 requires --trust <pinned-root.json> and --revocation-journal <latest.json>.");
+        const report = verifyEvidencePacketV02(packet, await readJson(trustPath), new Date(), await readJson(revocationPath));
+        process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+        if (report.overall !== "PASS")
+            process.exitCode = 1;
+    }
+    else {
+        const report = verifyEvidencePacket(packet, new Date(), trustPath ? await readJson(trustPath) : undefined);
+        process.stdout.write(readBoolFlag("--json") ? `${JSON.stringify(report, null, 2)}\n` : renderOfflineVerification(report));
+        if (report.overall !== "PASS")
+            process.exitCode = 1;
+    }
+}
+else if (command === "demo") {
+    if (process.argv[3] !== "assurance-loop")
+        throw new Error("Use witnora demo assurance-loop.");
+    const attack = (readFlag("--attack") ?? "none");
+    if (!["none", "parameter-substitution", "replay", "false-success", "event-tamper"].includes(attack))
+        throw new Error("Unsupported --attack value.");
+    const outcome = await runAssuranceLoopDemo({ outDir: readFlag("--out") ?? ".witnora/assurance-loop", attack });
+    process.stdout.write(renderOfflineVerification(outcome.report));
+    process.stdout.write(`Evidence packet: ${outcome.packetPath}\nTrust bundle: ${outcome.trustBundlePath}\nVerification report: ${outcome.reportPath}\nRevalidation diff: ${outcome.revalidationPath}\n`);
+    if (outcome.report.overall !== "PASS")
+        process.exitCode = 1;
+}
+else if (command === "import") {
+    if (readFlag("--format") !== "generic-eval")
+        throw new Error("Use witnora import --format generic-eval <result.json>.");
+    const path = process.argv.find((argument, index) => index >= 3 && !argument.startsWith("--") && process.argv[index - 1] !== "--format" && process.argv[index - 1] !== "--out");
+    if (!path)
+        throw new Error("A generic eval result path is required.");
+    const report = await importGenericEval(path, readBoolFlag("--dry-run") ? undefined : readFlag("--out") ?? ".witnora/import/generic-eval-report.json");
+    process.stdout.write(readBoolFlag("--json") ? `${JSON.stringify(report, null, 2)}\n` : renderGenericEvalReport(report));
+}
+else if (command === "onboard") {
+    const projectId = readFlag("--project") ?? brandedEnvironment("PROJECT_ID");
+    if (!projectId)
+        throw new Error("--project <project-id> is required.");
+    await runOnboard({
+        projectId,
+        server: readFlag("--server") ?? brandedEnvironment("BASE_URL") ?? DEFAULT_WITNORA_SERVER,
+        name: readFlag("--name"),
+        repository: readFlag("--repo") ?? process.cwd(),
+        template: readFlag("--template") ? parseAgentTemplate(readFlag("--template")) : undefined,
+        openBrowser: readBoolFlag("--no-browser") ? async () => { } : undefined,
+    });
+}
 else if (command === "try") {
     const template = parseAgentTemplate(readFlag("--template") ?? "workflow");
     const subject = readFlag("--subject") ?? `witnora-sample-${template}`;
@@ -599,6 +716,7 @@ else if (command === "conformance") {
 }
 else {
     process.stdout.write(`Usage:
+  witnora onboard --project <project-id>
   witnora try --template workflow [--push]
   witnora init --subject my-browser-agent
   witnora connect --server https://witnora.com --project <project-id>

package/dist/command-help.js

@@ -1,6 +1,82 @@
 export function renderCommandHelp(command) {
     if (command === "sandbox" || command === "browser-adapter")
         return undefined;
+    if (command === "onboard")
+        return `Usage:
+  witnora onboard --project <project-id>
+  witnora onboard --project <project-id> --template <browser|coding|mcp|workflow|data>
+
+Opens one browser authorization, saves a restricted project credential, detects the repository,
+writes missing starter files, and records an isolated synthetic self-test receipt. The self-test
+does not create assurance evidence or establish CURRENT status.
+
+Options:
+  --server <url>          Hosted server (default: https://witnora.com)
+  --project <id>          Project to authorize (required)
+  --name <name>           Saved connection name (default: repository name)
+  --repo <directory>      Repository to configure (default: current directory)
+  --template <type>       Override automatic repository detection
+  --no-browser            Print the approval URL without opening it
+`;
+    if (command === "design-partner")
+        return `Usage:
+  witnora design-partner init github-pr-merge [--out .witnora/design-partner]
+  witnora design-partner doctor [--dir .witnora/design-partner]
+  witnora design-partner privacy inspect
+  witnora design-partner trust inspect
+  witnora design-partner trust revoke-probe [--effective-at <timestamp>] [--retroactive]
+  witnora design-partner trust rotate-probe
+  witnora design-partner dry-run
+  witnora design-partner run-acceptance
+  witnora design-partner prepare-live-github --repository owner/sandbox-repo --pull-request 1
+  witnora design-partner verify-offline --packet <packet.json> --root <pinned-root.json> [--revocation-journal <latest.json>]
+
+The v0.2 acceptance path is emulator-only. The optional live GitHub command is a
+read-only preflight and cannot mutate or produce acceptance evidence for a repository.
+`;
+    if (command === "contract")
+        return `Usage:
+  witnora contract init [--out witnora.assurance-contract.json]
+  witnora contract validate <contract.json>
+  witnora contract compile <contract.json> [--out compiled-contract.json]
+  witnora contract diff --from previous.json --to next.json
+  witnora contract explain <contract.json>
+
+Contracts are strict JSON (also valid YAML 1.2). Unknown fields are rejected.
+`;
+    if (command === "privacy")
+        return `Usage:
+  witnora privacy init [--out witnora.privacy-manifest.json]
+  witnora privacy inspect <manifest.json>
+
+The manifest defaults to deny and classifies fields as local_only, disclose, or commit_only.
+`;
+    if (command === "verify")
+        return `Usage:
+  witnora verify --offline <witnora-evidence-packet.json> --trust <trust-bundle.json>
+  witnora verify --offline <packet.json> --trust <trust-bundle.json> --json
+
+Performs deterministic local verification without network access. Keys embedded in a packet
+are never trust anchors; missing caller-supplied trust returns UNVERIFIABLE.
+`;
+    if (command === "demo")
+        return `Usage:
+  witnora demo assurance-loop [--out .witnora/assurance-loop]
+  witnora demo assurance-loop --attack <parameter-substitution|replay|false-success|event-tamper>
+
+Runs a generic local high-risk action through contract, policy, approval, single-use grant,
+controlled execution, independent observation, signed evidence, and offline verification.
+No external system or credential is used.
+`;
+    if (command === "import")
+        return `Usage:
+  witnora import --format generic-eval <result.json> [--out .witnora/import/generic-eval-report.json]
+  witnora import --format generic-eval <result.json> --dry-run
+
+Normalizes framework-independent evaluation results and reports apparent success,
+independently verified success, Assurance Gap, explicit denominators, and exclusions.
+Imported results are unreviewed and never establish CURRENT assurance.
+`;
     if (command === "setup")
         return `Usage:
   witnora setup apply --plan witnora-setup-plan.json --repo .

package/dist/control-plane.js

@@ -30,13 +30,13 @@ export async function verifyControlPlaneConnection(options) {
     }
     catch (error) {
         if (error instanceof ControlPlaneRequestError && error.status === 401) {
-            throw new Error("AgentCert API key was rejected. Create a new project API key and try again.");
+            throw new Error("Witnora API key was rejected. Run `witnora onboard --project <project-id>` again or replace the revoked key.");
         }
         if (error instanceof ControlPlaneRequestError && error.status === 403) {
-            throw new Error(`AgentCert API key cannot access project ${options.projectId}. Check the project ID and key scope.`);
+            throw new Error(`Witnora API key cannot access project ${options.projectId}. Check the project ID and key scope.`);
         }
         if (error instanceof ControlPlaneRequestError && error.status === 404) {
-            throw new Error(`AgentCert project ${options.projectId} was not found.`);
+            throw new Error(`Witnora project ${options.projectId} was not found.`);
         }
         throw error;
     }

package/dist/credentials.js

@@ -46,7 +46,7 @@ export async function resolveConnection(options = {}) {
     };
     const missing = Object.entries(candidate).filter(([, value]) => !value).map(([key]) => key);
     if (missing.length > 0) {
-        throw new Error(`Hosted connection is incomplete (${missing.join(", ")} missing). Run \`witnora connect\` or set WITNORA_BASE_URL, WITNORA_PROJECT_ID, and WITNORA_API_KEY. Legacy AGENTCERT_* variables remain supported.`);
+        throw new Error(`Hosted connection is incomplete (${missing.join(", ")} missing). Run \`witnora onboard --project <project-id>\` or set WITNORA_BASE_URL, WITNORA_PROJECT_ID, and WITNORA_API_KEY. Legacy AGENTCERT_* variables remain supported.`);
     }
     return validateConnection(candidate);
 }