@nexart/cli 0.6.0 → 0.8.0

package/dist/index.js

@@ -1,27 +1,58 @@
 #!/usr/bin/env node
 /**
- * @nexart/cli v0.6.0 — NexArt CLI
+ * @nexart/cli v0.8.0 — NexArt CLI
  *
  * Code Mode commands:
- * - nexart run <file>      — Execute via remote renderer and create snapshot
+ * - nexart run <file>        — Execute via remote renderer and create snapshot
  * - nexart replay <snapshot> — Re-execute from snapshot
  * - nexart verify <snapshot> — Verify snapshot hash
  *
  * AI Certification commands:
- * - nexart ai create <file>  — Create a CER bundle via node API
- * - nexart ai certify <file> — Certify an AI execution and attest
- * - nexart ai verify <file>  — Verify a CER bundle or CER package locally (signals-aware)
+ * - nexart ai create <file>         — Create a CER bundle via node API
+ * - nexart ai certify <file>        — Certify an AI execution and attest
+ * - nexart ai seal <file>           — Seal a CER bundle locally (offline, no node)
+ * - nexart ai verify <file>         — Verify a CER bundle or CER package locally
+ * - nexart ai project-verify <file> — Verify a cer.project.bundle.v1 artifact locally
  *
- * Context signals (v0.5.0+):
+ * Sealed vs Certified:
+ *   - Sealed     = integrity only. Bundle is locally produced via SDK sealCer().
+ *                  No node receipt, no signature, no envelope. Use for offline
+ *                  workflows, CI, or pre-certification staging. `ai seal` builds
+ *                  these.
+ *   - Certified  = integrity + node attestation receipt. Bundle has been
+ *                  attested by a NexArt node and includes a signed receipt.
+ *                  `ai certify` builds these.
+ *   `ai verify` works on both. For sealed bundles, the Receipt and Envelope
+ *   layers report SKIPPED — that is correct, not a failure.
+ *
+ * VERIFICATION ALIGNMENT (v0.8.0):
+ *   `ai verify` and `ai project-verify` both delegate ALL verification logic to
+ *   @nexart/ai-execution (>=0.16.1). The CLI implements ZERO independent
+ *   cryptographic logic — no canonicalization, no hash recomputation, no
+ *   integrity checks. This guarantees byte-for-byte parity with:
+ *     - the SDK (`verifyAiCerBundleDetailed`, `verifyProjectBundle`)
+ *     - NexArt Node (`/v1/cer/verify`)
+ *     - verify.nexart.io
+ *
+ *   `ai verify` reports the three SDK protocol layers independently:
+ *     - bundleIntegrity   (Integrity: certificate hash recomputation)
+ *     - nodeSignature     (Receipt:   node attestation signature validity)
+ *     - receiptConsistency (Envelope: bundle/receipt envelope consistency)
+ *   Each layer is reported as PASS / FAIL / SKIPPED with no aggregation, and
+ *   the SDK reason codes are passed through unmodified.
+ *
+ * Context signals:
  *   Pass --signals-file <path> to ai create / ai certify to attach upstream
- *   context signals to the CER. Signals are evidence-only and are included in
- *   the certificateHash. ai verify handles signals-containing bundles correctly.
+ *   context signals to the CER. Signals are evidence and are bound by the
+ *   SDK into the certificateHash. ai verify validates them via the SDK.
  *
- * CER packages (v0.6.0+):
- *   nexart ai verify accepts both raw CER bundles and CER packages.
- *   A CER package is { cer: <bundle>, receipt?, signature?, ... }.
- *   Only the inner cer bundle is verified. Package-level receipt/signature/
- *   envelope fields are not verified by this command.
+ * CER packages:
+ *   ai verify accepts raw CER bundles and CER packages. For packages, the
+ *   inner CER bundle is unwrapped and passed to the SDK verifier.
+ *
+ * Project bundles:
+ *   ai project-verify delegates to verifyProjectBundle() from @nexart/ai-execution.
+ *   No network required. The CLI provides command surface and output formatting only.
  */
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
@@ -32,12 +63,44 @@ import * as http from 'http';
 import * as https from 'https';
 import { fileURLToPath } from 'url';
 import { realpathSync } from 'fs';
-const CLI_VERSION = '0.6.0';
-const SDK_VERSION = '1.10.1';
+import { createRequire } from 'module';
+import { verifyProjectBundle, verifyAiCerBundleDetailed, hasAttestation as sdkHasAttestation, isCerPackage as sdkIsCerPackage, getCerFromPackage, createSnapshot as sdkCreateSnapshot, sealCer as sdkSealCer, } from '@nexart/ai-execution';
+const CLI_VERSION = '0.8.0';
+/**
+ * Code Mode renderer protocol version. This is the wire-protocol version the
+ * CLI sends to the remote renderer for snapshot creation. It is unrelated to
+ * the AI CER protocol (which is owned and versioned by @nexart/ai-execution).
+ */
 const PROTOCOL_VERSION = '1.2.0';
+/**
+ * Stable fallback identifier used when computing a Code Mode `runtimeHash`
+ * locally (e.g. when the remote renderer doesn't supply one). This is NOT a
+ * CER hash and is NOT part of any verification path — it just needs to be
+ * stable across replays of the same CLI version.
+ */
+const CODE_MODE_RUNTIME_TAG = `nexart-cli/${CLI_VERSION}`;
+/**
+ * Read the installed @nexart/ai-execution version at runtime from its
+ * package.json. Used by --version output so what the CLI reports always
+ * matches what is actually loaded.
+ */
+function getSdkVersion() {
+    try {
+        const req = createRequire(import.meta.url);
+        const pkg = req('@nexart/ai-execution/package.json');
+        return typeof pkg.version === 'string' ? pkg.version : 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
 const DEFAULT_ENDPOINT = process.env.NEXART_RENDERER_ENDPOINT || 'http://localhost:5000';
 const DEFAULT_API_KEY = process.env.NEXART_API_KEY || '';
 const DEFAULT_NODE_ENDPOINT = process.env.NEXART_NODE_ENDPOINT || 'https://node.nexart.art';
+// NOTE: A local `CerBundle` shape used to live here. It has been removed in
+// v0.8.0 — the canonical CER bundle type is `CerAiExecutionBundle` from
+// @nexart/ai-execution, which the CLI imports directly. Keeping a parallel
+// type would risk drift from the SDK schema.
 function sha256(data) {
     const buffer = typeof data === 'string' ? Buffer.from(data, 'utf-8') : data;
     return crypto.createHash('sha256').update(buffer).digest('hex');
@@ -186,7 +249,7 @@ async function callRenderer(endpoint, code, seed, VAR, width, height, apiKey) {
                     return;
                 }
                 if (contentType.includes('image/png')) {
-                    const runtimeHash = res.headers['x-runtime-hash'] || sha256(SDK_VERSION);
+                    const runtimeHash = res.headers['x-runtime-hash'] || sha256(CODE_MODE_RUNTIME_TAG);
                     resolve({ pngBytes: responseBuffer, runtimeHash });
                     return;
                 }
@@ -198,7 +261,7 @@ async function callRenderer(endpoint, code, seed, VAR, width, height, apiKey) {
                     }
                     if (json.pngBase64) {
                         const pngBytes = Buffer.from(json.pngBase64, 'base64');
-                        const runtimeHash = json.runtimeHash || sha256(SDK_VERSION);
+                        const runtimeHash = json.runtimeHash || sha256(CODE_MODE_RUNTIME_TAG);
                         resolve({ pngBytes, runtimeHash });
                         return;
                     }
@@ -269,7 +332,7 @@ async function runCommand(file, options) {
     else {
         console.log(`[nexart] WARNING: Local renderer NOT implemented yet — outputs placeholder image only`);
         pngBytes = createPlaceholderPng();
-        runtimeHash = options.runtimeHash || sha256(SDK_VERSION);
+        runtimeHash = options.runtimeHash || sha256(CODE_MODE_RUNTIME_TAG);
     }
     const outputHash = sha256(pngBytes);
     const snapshot = {
@@ -546,48 +609,19 @@ export async function callNodeApi(endpoint, apiPath, body, apiKey, fetchFn = glo
     return { status: response.status, data };
 }
 /**
- * Deterministic canonical JSON serialization matching CER v1 spec:
- * - Object keys sorted lexicographically
- * - Nested objects recursively sorted
- * - Arrays maintain insertion order
- * - undefined values omitted
- */
-export function canonicalJson(value) {
-    if (value === null || typeof value !== 'object') {
-        return JSON.stringify(value);
-    }
-    if (Array.isArray(value)) {
-        return '[' + value.map(canonicalJson).join(',') + ']';
-    }
-    const obj = value;
-    const keys = Object.keys(obj).sort();
-    const pairs = keys
-        .filter(k => obj[k] !== undefined)
-        .map(k => JSON.stringify(k) + ':' + canonicalJson(obj[k]));
-    return '{' + pairs.join(',') + '}';
-}
-/**
- * Recompute the certificateHash for a CER v1 bundle.
- * Protected set: { bundleType, version, createdAt, snapshot }
- * v0.11.0+: context is included in the protected set when present (non-null/non-undefined),
- * ensuring signals are tamper-evident. When absent, the hash is identical to pre-v0.11.0.
+ * NOTE: As of v0.8.0, the CLI implements ZERO independent cryptographic logic.
+ *
+ * Removed in v0.8.0 (drift hazard — canonical CER semantics live in the SDK):
+ *   - canonicalJson()      → use @nexart/ai-execution canonicalization
+ *   - computeBundleHash()  → use verifyAiCerBundleDetailed() / verifyCer()
+ *   - hasAttestation()     → re-exported below from @nexart/ai-execution
+ *
+ * The CLI MUST NOT recompute certificateHash, canonicalize CER JSON, or compare
+ * hashes by hand. All such logic is owned by @nexart/ai-execution. This is what
+ * guarantees CLI verification matches the SDK, NexArt Node (`/v1/cer/verify`),
+ * and verify.nexart.io exactly.
  */
-export function computeBundleHash(bundle) {
-    const { bundleType, version, createdAt, snapshot } = bundle;
-    const protectedSet = { bundleType, version, createdAt, snapshot };
-    const context = bundle['context'];
-    if (context !== undefined && context !== null) {
-        protectedSet['context'] = context;
-    }
-    return 'sha256:' + sha256(canonicalJson(protectedSet));
-}
-/**
- * Check whether a CER bundle has a valid-looking attestation.
- */
-export function hasAttestation(bundle) {
-    return (typeof bundle['attestationId'] === 'string' &&
-        bundle['attestationId'].length > 0);
-}
+export const hasAttestation = sdkHasAttestation;
 /**
  * Load a JSON array of context signals from a file path.
  * Exits with an error message if the file is missing, invalid JSON, or not an array.
@@ -619,6 +653,111 @@ export function loadSignalsFile(signalsPath) {
     }
     return parsed;
 }
+/**
+ * Internal: validate that `raw` looks like a CreateSnapshotParams payload and
+ * return a typed object (plus optional seal-time inputs). The CLI owns input
+ * shape validation only — it does NOT touch crypto or canonicalization. All
+ * structural CER semantics belong to the SDK.
+ *
+ * Required fields: executionId, provider, model, prompt, input, output, parameters
+ * Seal-time optionals (top-level on the payload): createdAt, signals, meta, declaration
+ */
+function buildSealInputs(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        console.error('[nexart] Error: Input must be a JSON object describing an AI execution.');
+        process.exit(1);
+    }
+    const obj = raw;
+    const required = ['executionId', 'provider', 'model', 'prompt', 'input', 'output', 'parameters'];
+    const missing = required.filter((k) => obj[k] === undefined || obj[k] === null);
+    if (missing.length > 0) {
+        console.error(`[nexart] Error: Missing required field(s) for ai seal: ${missing.join(', ')}`);
+        console.error('[nexart] Required fields: executionId, provider, model, prompt, input, output, parameters');
+        process.exit(1);
+    }
+    if (typeof obj.parameters !== 'object' || obj.parameters === null || Array.isArray(obj.parameters)) {
+        console.error('[nexart] Error: `parameters` must be an object (AiExecutionParameters).');
+        process.exit(1);
+    }
+    // Pass the payload through to createSnapshot. The SDK is the schema authority
+    // and will throw structured errors on anything it does not accept.
+    const snapshotParams = obj;
+    const sealOptions = {};
+    if (typeof obj.createdAt === 'string')
+        sealOptions.createdAt = obj.createdAt;
+    if (Array.isArray(obj.signals))
+        sealOptions.signals = obj.signals;
+    if (obj.meta && typeof obj.meta === 'object' && !Array.isArray(obj.meta)) {
+        sealOptions.meta = obj.meta;
+    }
+    if (obj.declaration && typeof obj.declaration === 'object' && !Array.isArray(obj.declaration)) {
+        sealOptions.declaration = obj.declaration;
+    }
+    return { snapshotParams, sealOptions };
+}
+/**
+ * nexart ai seal — Build a Certified Execution Record locally.
+ *
+ * This command is offline-only. It performs ZERO network I/O and ZERO local
+ * cryptography: all snapshot construction, canonicalization, and certificate
+ * hashing are delegated to @nexart/ai-execution via createSnapshot() and
+ * sealCer(). The CLI's job is parsing input, calling the SDK, and formatting
+ * output.
+ *
+ * Output contract:
+ *   - stdout: the CER bundle JSON (pipe-friendly into `nexart ai verify`)
+ *   - stderr: a status banner (suppress with --quiet)
+ *   - --out:  also writes the bundle JSON to the given file
+ *
+ * The sealed bundle is integrity-only. It does NOT contain a node attestation
+ * receipt, a node signature, or an envelope. Use `nexart ai certify` (or
+ * `attest()` from the SDK) to upgrade a sealed bundle to a certified one.
+ *
+ * Compatibility guarantee: a sealed bundle from this command verifies as
+ * VERIFIED by `nexart ai verify`, by SDK `verifyAiCerBundleDetailed`, and by
+ * NexArt Node `/v1/cer/verify` (Integrity layer PASS, Receipt and Envelope
+ * layers SKIPPED — that is by design, not a failure).
+ *
+ * To merge upstream context signals into the bundle, include `signals: [...]`
+ * in the input JSON. Signals are bound by the SDK into certificateHash via
+ * context.contextHash + signalCount + contextSummary.
+ */
+export async function aiSealCommand(file, opts, stdinReader = readStdinText) {
+    const raw = await readInputJson(file, stdinReader);
+    const { snapshotParams, sealOptions } = buildSealInputs(raw);
+    // Single source of truth: SDK builds the snapshot and seals it.
+    let bundle;
+    try {
+        const snapshot = sdkCreateSnapshot(snapshotParams);
+        bundle = sdkSealCer(snapshot, sealOptions);
+    }
+    catch (e) {
+        console.error(`[nexart] Error: SDK seal failed: ${e.message}`);
+        process.exit(1);
+    }
+    // Defensive invariant: a freshly sealed bundle must NOT carry an attestation.
+    // If the SDK ever returns one, surface it loudly rather than silently shipping
+    // a misclassified artifact.
+    if (sdkHasAttestation(bundle)) {
+        console.error('[nexart] Error: SDK returned a bundle with an attestation; refusing to label as sealed.');
+        process.exit(1);
+    }
+    const bundleJson = JSON.stringify(bundle, null, 2);
+    process.stdout.write(bundleJson + '\n');
+    if (opts.out) {
+        const outPath = writeFileAndVerify(opts.out, bundleJson);
+        console.error(`[nexart] Saved to: ${outPath}`);
+    }
+    if (!opts.quiet) {
+        const certHash = bundle.certificateHash ?? '(missing)';
+        console.error('');
+        console.error('[nexart] Local CER created');
+        console.error('[nexart] State: Sealed (integrity only)');
+        console.error('[nexart] No node attestation present');
+        console.error('[nexart] This record is not certified — use `nexart ai certify` to attest via a node');
+        console.error(`[nexart] certificateHash: ${certHash}`);
+    }
+}
 /**
  * nexart ai create — Read execution input, call POST /v1/cer/ai/create,
  * print CER bundle JSON to stdout, optionally save to --out file.
@@ -730,94 +869,200 @@ export async function aiCertifyCommand(file, opts, fetchFn = globalThis.fetch, s
     }
 }
 /**
- * Check whether the input looks like a CER package — an envelope object with
- * a `cer` field whose `bundleType` is 'cer.ai.execution.v1'.
+ * nexart ai verify — Read a CER bundle or CER package JSON from file or stdin,
+ * delegate verification to verifyAiCerBundleDetailed() from @nexart/ai-execution,
+ * and report the protocol layer results.
+ *
+ * The CLI does ZERO crypto here. It only:
+ *   1. parses input
+ *   2. unwraps a CER package to its inner CER bundle (via SDK's isCerPackage / getCerFromPackage)
+ *   3. calls verifyAiCerBundleDetailed(bundle)
+ *   4. formats the SDK's CerVerificationResult for human / JSON output
  *
- * Mirrors the logic of isCerPackage() from @nexart/ai-execution without
- * adding a runtime dependency. The CLI is intentionally self-contained.
+ * The three SDK protocol layers are reported INDEPENDENTLY (no aggregation):
+ *   - bundleIntegrity   (Integrity layer:  certificate hash recomputation)
+ *   - nodeSignature     (Receipt layer:    node attestation signature validity)
+ *   - receiptConsistency (Envelope layer:  bundle/receipt envelope consistency)
+ *
+ * Each layer is PASS / FAIL / SKIPPED. SDK reason codes are passed through
+ * unmodified. Exit code is driven by the SDK's `status` field (VERIFIED → 0,
+ * anything else → 1).
+ *
+ * --json prints the SDK's CerVerificationResult verbatim, plus a minimal
+ * `cli` envelope describing input handling. The SDK fields are never rewritten
+ * or reinterpreted.
  */
-function isCerPackageInput(value) {
-    const cer = value['cer'];
-    if (typeof cer !== 'object' || cer === null)
-        return false;
-    return cer['bundleType'] === 'cer.ai.execution.v1';
+export async function aiVerifyCommand(file, opts, stdinReader = readStdinText) {
+    const raw = await readInputJson(file, stdinReader);
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        console.error('[nexart] Error: Input is not a valid CER bundle or CER package object');
+        process.exit(1);
+    }
+    // Detect package vs raw bundle and unwrap. Both helpers are from the SDK,
+    // so the CLI stays in sync with however the SDK defines a "package".
+    const isPackage = sdkIsCerPackage(raw);
+    const inputType = isPackage ? 'package' : 'bundle';
+    let bundleForVerification;
+    if (isPackage) {
+        bundleForVerification = getCerFromPackage(raw);
+    }
+    else {
+        bundleForVerification = raw;
+    }
+    // Delegate ALL verification to the SDK. The CLI does not interpret, fall
+    // back, or aggregate. The result object is the protocol's source of truth.
+    const result = verifyAiCerBundleDetailed(bundleForVerification);
+    if (opts.json) {
+        // Pass the SDK result through verbatim. Add only a small `cli` envelope
+        // so callers can tell whether the input was a bundle or a package and
+        // which CLI version produced the output. SDK fields are NOT modified.
+        const output = {
+            ...result,
+            cli: {
+                version: CLI_VERSION,
+                sdkVersion: getSdkVersion(),
+                inputType,
+                ...(isPackage
+                    ? {
+                        verifiedInnerCer: true,
+                        packageTrustLayersVerified: false,
+                    }
+                    : {}),
+            },
+        };
+        process.stdout.write(JSON.stringify(output, null, 2) + '\n');
+    }
+    else {
+        if (isPackage) {
+            console.log('Input type: CER package');
+        }
+        else {
+            console.log('Input type: CER bundle');
+        }
+        console.log(`Verification result: ${result.status}`);
+        console.log(`bundleType:          ${result.bundleType || '(missing)'}`);
+        console.log(`certificateHash:     ${result.certificateHash || '(missing)'}`);
+        console.log('');
+        console.log('Layers:');
+        console.log(`  bundleIntegrity    (Integrity): ${result.checks.bundleIntegrity}`);
+        console.log(`  nodeSignature      (Receipt):   ${result.checks.nodeSignature}`);
+        console.log(`  receiptConsistency (Envelope):  ${result.checks.receiptConsistency}`);
+        if (result.reasonCodes.length > 0) {
+            console.log('');
+            console.log('Reason codes:');
+            for (const code of result.reasonCodes) {
+                console.log(`  - ${code}`);
+            }
+        }
+        console.log('');
+        console.log(`Verifier:   ${result.verifier} (via @nexart/cli ${CLI_VERSION})`);
+        console.log(`VerifiedAt: ${result.verifiedAt}`);
+        if (isPackage) {
+            console.log('');
+            console.log('Note: Verified inner CER bundle only. Package-level receipt/signature/envelope not verified by this command.');
+        }
+    }
+    process.exit(result.status === 'VERIFIED' ? 0 : 1);
 }
 /**
- * nexart ai verify — Read a CER bundle or CER package JSON from file or stdin,
- * verify integrity locally, report VERIFIED/FAILED.
- * --json outputs a canonical CerVerificationResult object.
+ * nexart ai project-verify — Read a cer.project.bundle.v1 JSON from file or stdin,
+ * delegate all verification to verifyProjectBundle() from @nexart/ai-execution,
+ * and report VERIFIED/FAILED.
+ *
+ * CLI responsibilities:
+ *   - file/stdin input handling
+ *   - artifact type routing (early discriminant check for clear user-facing errors)
+ *   - calling verifyProjectBundle() from @nexart/ai-execution (canonical source of truth)
+ *   - formatting ProjectBundleVerifyResult for human-readable terminal output
+ *   - emitting the structured result in JSON mode
  *
- * v0.6.0: Also accepts CER packages ({ cer: <bundle>, receipt?, signature?, ... }).
- * When a package is detected, only the inner cer bundle is verified.
- * Package-level receipt/signature/envelope fields are NOT verified by this command.
+ * The CLI does NOT own project bundle schema, project hash computation,
+ * per-step verification logic, or any competing implementation of those semantics.
+ *
+ * Exit code: 0 on VERIFIED, 1 on FAILED or structural error.
+ * --json outputs a machine-readable result object.
  */
-export async function aiVerifyCommand(file, opts, stdinReader = readStdinText) {
+export async function aiProjectVerifyCommand(file, opts, stdinReader = readStdinText) {
     const raw = await readInputJson(file, stdinReader);
     if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-        console.error('[nexart] Error: Input is not a valid CER bundle object');
+        console.error('[nexart] Error: Input is not a valid project bundle object');
         process.exit(1);
     }
     const input = raw;
-    const verifiedAt = new Date().toISOString();
-    // Detect whether input is a raw CER bundle or a CER package.
-    const isPackage = isCerPackageInput(input);
-    const inputType = isPackage ? 'package' : 'bundle';
-    // Extract the bundle to verify: package → inner cer; raw bundle → itself.
-    const bundle = isPackage
-        ? input['cer']
-        : input;
-    const bundleType = typeof bundle['bundleType'] === 'string' ? bundle['bundleType'] : '';
-    const certificateHash = typeof bundle['certificateHash'] === 'string' ? bundle['certificateHash'] : '';
-    if (bundleType !== 'cer.ai.execution.v1') {
-        console.error(`[nexart] Error: Unsupported bundleType: ${bundleType}`);
-        console.error('[nexart] Expected: cer.ai.execution.v1');
+    // Early discriminant check — provides a clear user-facing error before delegating.
+    if (input['bundleType'] !== 'cer.project.bundle.v1') {
+        const got = typeof input['bundleType'] === 'string' ? input['bundleType'] : '(missing)';
+        console.error(`[nexart] Error: Unsupported bundleType: ${got}`);
+        console.error('[nexart] Expected: cer.project.bundle.v1');
         process.exit(1);
     }
-    const computedHash = computeBundleHash(bundle);
-    const integrityPass = computedHash === certificateHash;
-    const attestationPresent = hasAttestation(bundle);
-    const nodeSignature = attestationPresent ? 'PASS' : 'SKIPPED';
-    const receiptConsistency = attestationPresent ? 'PASS' : 'SKIPPED';
-    const reasonCodes = integrityPass ? [] : ['BUNDLE_HASH_MISMATCH'];
-    const status = integrityPass ? 'VERIFIED' : 'FAILED';
-    if (opts.json) {
+    // Delegate all verification logic to @nexart/ai-execution — the canonical source of truth.
+    const result = verifyProjectBundle(raw);
+    const verifiedAt = new Date().toISOString();
+    emitProjectVerifyResult(result, verifiedAt, opts.json, input);
+    process.exit(result.ok ? 0 : 1);
+}
+/**
+ * Format a ProjectBundleVerifyResult returned by verifyProjectBundle() from
+ * @nexart/ai-execution into human-readable or JSON terminal output.
+ *
+ * The raw input bundle is accepted only for output-only display fields that
+ * are not carried in ProjectBundleVerifyResult: projectBundleId, projectTitle.
+ * All verification logic and semantic fields come from the result object.
+ */
+function emitProjectVerifyResult(result, verifiedAt, json, input) {
+    const status = result.ok ? 'VERIFIED' : 'FAILED';
+    const passedSteps = result.passedSteps ?? result.steps.filter(s => s.ok).length;
+    const failedSteps = result.failedSteps ?? result.steps.filter(s => !s.ok).length;
+    const structuralValid = result.structuralValid ?? result.ok;
+    const projectHashIntegrity = result.projectHashValid === true ? 'PASS' :
+        result.projectHashValid === false ? 'FAIL' :
+            'SKIPPED';
+    const stepIntegrity = result.steps.length === 0 ? 'SKIPPED' :
+        result.steps.every(s => s.ok) ? 'PASS' : 'FAIL';
+    const totalSteps = result.totalSteps ?? (typeof input['totalSteps'] === 'number' ? input['totalSteps'] : null);
+    if (json) {
         const output = {
             status,
+            bundleType: 'cer.project.bundle.v1',
+            projectBundleId: typeof input['projectBundleId'] === 'string' ? input['projectBundleId'] : null,
+            projectTitle: typeof input['projectTitle'] === 'string' ? input['projectTitle'] : null,
+            totalSteps,
+            passedSteps,
+            failedSteps,
+            projectHashValid: result.projectHashValid ?? null,
             checks: {
-                bundleIntegrity: integrityPass ? 'PASS' : 'FAIL',
-                nodeSignature,
-                receiptConsistency,
+                structuralValid,
+                projectHashIntegrity,
+                stepIntegrity,
             },
-            reasonCodes,
-            certificateHash,
-            bundleType,
-            inputType,
+            steps: result.steps,
+            errors: result.errors,
             verifiedAt,
             verifier: '@nexart/cli',
         };
-        if (isPackage) {
-            output['verifiedInnerCer'] = true;
-            output['packageTrustLayersVerified'] = false;
-        }
         process.stdout.write(JSON.stringify(output, null, 2) + '\n');
     }
     else {
-        if (isPackage) {
-            console.log('Input type: CER package');
-        }
         console.log(`Verification result: ${status}`);
-        console.log(`bundleIntegrity: ${integrityPass ? 'PASS' : 'FAIL'}`);
-        console.log(`nodeSignature: ${nodeSignature}`);
-        console.log(`receiptConsistency: ${receiptConsistency}`);
-        if (isPackage) {
-            console.log('Note: Verified inner CER bundle only. Package-level receipt/signature/envelope not verified by this command.');
+        console.log(`bundleType: cer.project.bundle.v1`);
+        if (typeof input['projectBundleId'] === 'string') {
+            console.log(`projectBundleId: ${input['projectBundleId']}`);
+        }
+        if (typeof input['projectTitle'] === 'string') {
+            console.log(`projectTitle: ${input['projectTitle']}`);
+        }
+        if (totalSteps !== null) {
+            console.log(`totalSteps: ${totalSteps}`);
         }
-        if (!integrityPass) {
-            console.error(`[nexart] Expected hash: ${certificateHash}`);
-            console.error(`[nexart] Computed hash: ${computedHash}`);
+        console.log(`passedSteps: ${passedSteps}`);
+        console.log(`failedSteps: ${failedSteps}`);
+        console.log(`projectHashIntegrity: ${projectHashIntegrity}`);
+        console.log(`stepIntegrity: ${stepIntegrity}`);
+        for (const err of result.errors) {
+            console.error(`[nexart] Error: ${err}`);
         }
     }
-    process.exit(integrityPass ? 0 : 1);
 }
 // ─── CLI Setup ─────────────────────────────────────────────────────────────
 const _isMainModule = (() => {
@@ -1054,7 +1299,38 @@ if (_isMainModule) {
         }, async (argv) => {
             await aiCertifyCommand(argv.file, { out: argv.out, json: argv.json, endpoint: argv.endpoint, apiKey: argv['api-key'], signalsFile: argv['signals-file'] });
         })
-            .command('verify [file]', 'Verify a CER bundle or CER package locally (no network required)', (yargs) => {
+            .command('seal [file]', 'Create a Certified Execution Record locally (no node required) — produces an integrity-only bundle for offline workflows, CI, or pre-certification', (yargs) => {
+            return yargs
+                .positional('file', {
+                describe: 'Path to execution input JSON (omit to read from stdin)',
+                type: 'string',
+            })
+                .option('out', {
+                alias: 'o',
+                describe: 'Save sealed CER bundle to this file',
+                type: 'string',
+            })
+                .option('quiet', {
+                alias: 'q',
+                describe: 'Suppress the human-readable status banner on stderr (clean pipe output)',
+                type: 'boolean',
+                default: false,
+            })
+                .example('$0 ai seal execution.json', 'Seal locally and print bundle JSON')
+                .example('cat execution.json | $0 ai seal --quiet | $0 ai verify', 'Seal then verify in a pipe')
+                .example('$0 ai seal execution.json --out cer.json', 'Save sealed bundle to file')
+                .example('$0 ai seal execution.json --quiet > cer.json', 'Redirect bundle JSON only')
+                .epilogue([
+                'Sealed (this command):  integrity only. No node receipt, no signature, no envelope.',
+                'Certified (ai certify): integrity + node attestation receipt + signature.',
+                '',
+                'A sealed bundle verifies as VERIFIED with Receipt and Envelope reported as SKIPPED.',
+                'That is correct, not a failure: only the Integrity layer applies to local artifacts.',
+            ].join('\n'));
+        }, async (argv) => {
+            await aiSealCommand(argv.file, { out: argv.out, quiet: argv.quiet });
+        })
+            .command('verify [file]', 'Verify a CER bundle or CER package locally via @nexart/ai-execution (no network required)', (yargs) => {
             return yargs
                 .positional('file', {
                 describe: 'Path to CER bundle or CER package JSON (omit to read from stdin)',
@@ -1073,23 +1349,55 @@ if (_isMainModule) {
         }, async (argv) => {
             await aiVerifyCommand(argv.file, { json: argv.json });
         })
-            .demandCommand(1, 'You must provide a subcommand: create, certify, or verify')
+            .command('project-verify [file]', 'Verify a project bundle (cer.project.bundle.v1) locally (no network required)', (yargs) => {
+            return yargs
+                .positional('file', {
+                describe: 'Path to project bundle JSON (omit to read from stdin)',
+                type: 'string',
+            })
+                .option('json', {
+                alias: 'j',
+                describe: 'Print machine-readable JSON result',
+                type: 'boolean',
+                default: false,
+            })
+                .example('$0 ai project-verify bundle.json', 'Verify a project bundle file')
+                .example('cat bundle.json | $0 ai project-verify', 'Verify from stdin')
+                .example('$0 ai project-verify bundle.json --json', 'Machine-readable output');
+        }, async (argv) => {
+            await aiProjectVerifyCommand(argv.file, { json: argv.json });
+        })
+            .demandCommand(1, 'You must provide a subcommand: create, certify, verify, or project-verify')
             .help();
     }, () => { })
         .demandCommand(1, 'You must provide a command')
         .help()
-        .version(CLI_VERSION)
+        .version(`@nexart/cli           ${CLI_VERSION}
+@nexart/ai-execution  ${getSdkVersion()}
+codemode protocol     ${PROTOCOL_VERSION}`)
         .epilog(`
 Environment Variables:
   NEXART_RENDERER_ENDPOINT  Remote renderer URL (default: http://localhost:5000)
   NEXART_NODE_ENDPOINT      NexArt node API URL (default: https://node.nexart.art)
   NEXART_API_KEY            API key for authenticated requests
 
-Output Files:
+Output Files (Code Mode):
   --out ./out.png creates:
     ./out.png           - The rendered PNG image
     ./out.snapshot.json - Snapshot for replay/verify
 
+AI verification (ai verify, ai project-verify):
+  All cryptographic verification is delegated to @nexart/ai-execution
+  (verifyAiCerBundleDetailed, verifyProjectBundle). The CLI itself implements
+  no hashing or canonicalization and produces results that match the SDK,
+  NexArt Node (/v1/cer/verify), and verify.nexart.io exactly.
+
+  ai verify reports the three SDK protocol layers independently:
+    - bundleIntegrity   (Integrity: certificate hash recomputation)
+    - nodeSignature     (Receipt:   node attestation signature validity)
+    - receiptConsistency (Envelope: bundle/receipt envelope consistency)
+  No aggregation, no reinterpretation, SDK reason codes preserved verbatim.
+
 Examples:
   # Run with remote renderer
   npx @nexart/cli run ./sketch.js --seed 123 --include-code --out ./out.png
@@ -1109,11 +1417,17 @@ Examples:
   # AI: Certify with context signals
   npx @nexart/cli ai certify execution.json --signals-file signals.json
 
-  # AI: Verify a raw CER bundle locally (signals-containing bundles supported)
+  # AI: Verify a raw CER bundle locally (delegates to SDK)
   npx @nexart/cli ai verify cer.json
 
-  # AI: Verify a CER package (inner bundle verified; receipt/envelope not verified)
+  # AI: Verify a CER package (inner bundle verified via SDK; package envelope not)
   npx @nexart/cli ai verify cer-package.json
+
+  # AI: Verify a project bundle locally (no network required)
+  npx @nexart/cli ai project-verify project-bundle.json
+
+  # AI: Verify a project bundle with machine-readable JSON output
+  npx @nexart/cli ai project-verify project-bundle.json --json
   `)
         .parse();
 }