witnora 0.8.1 → 0.9.0

package/README.md

@@ -1,23 +1,286 @@
 # Witnora CLI
 
-`witnora` is the canonical npm entry point for the Witnora CLI.
+Unified release assurance, evidence, corpus, monitor, and lab CLI for Witnora.
+
+Witnora checks what an agent may do, whether it passed pre-release evidence,
+whether a high-risk runtime action may proceed, and who can verify the observed
+outcome. It writes portable reports and accumulates a local failure corpus.
+
+[Public evidence](https://witnora.com/evidence) |
+[Get started](https://witnora.com/docs) |
+[Private workspace](https://witnora.com/app) |
+[GitHub source](https://github.com/Kakarottoooo/agentcert)
+
+## 5-minute local path
+
+No agent repository or API key is required for the first run:
+
+```bash
+npx witnora@latest try --template workflow
+```
+
+Inspect `.witnora/try/agentcert-report.html` and
+`.witnora/try/agentcert-evidence.json`. The output is explicitly synthetic and
+reported-strength: it proves the evidence tooling works, not that a real agent
+is reliable.
+
+When you have an agent repository:
+
+```bash
+npx witnora init --template browser --subject my-browser-agent
+```
+
+This writes `witnora.config.json` and `tripwire.yml`. Add `--github-action`
+when you also want `.github/workflows/witnora-tripwire.yml`.
+
+Use the same entry point for other agent boundaries:
+
+```bash
+npx witnora init --template coding
+npx witnora init --template mcp
+npx witnora init --template workflow
+npx witnora init --template data
+```
+
+Coding, workflow, and data templates write a dependency-free Universal
+Event/Action Envelope adapter. MCP writes an MCPBench artifact profile.
+
+Hosted guided setup can export a redacted typed plan for the customer-owned
+runner:
+
+```bash
+npx witnora@latest setup apply --plan witnora-setup-plan.json --repo .
+```
+
+Add `--github-pr` only after reviewing the generated files. The runner accepts
+only the five Witnora templates and ignores commands embedded in a plan.
+Coding, workflow, and data integrations begin at observed-event strength; they
+do not establish `CURRENT` until a deterministic task assertion and outcome
+verifier are attached.
+
+Edit `tripwire.yml` so `startUrl` and `agent.command` point at your app and
+browser agent. After Tripwire has produced `.tripwire/latest/tripwire-result.json`,
+build the Witnora outputs:
+
+```bash
+npx witnora run --tripwire .tripwire/latest/tripwire-result.json --subject my-browser-agent --fail-on-verdict
+```
+
+Default outputs:
+
+- `.witnora/latest/agentcert-evidence.json`
+- `.witnora/latest/agentcert-report.md`
+- `.witnora/latest/agentcert-report.html`
+- `.witnora/latest/agentcert-run-manifest.json`
+- `.witnora/latest/badge.svg`
+- `.witnora/corpus/corpus.jsonl`
+- `.witnora/latest/reviewed-failure-dataset.jsonl`
+- `.witnora/latest/monitor.json`
+
+Push the validated evidence bundle into a hosted Witnora project:
+
+```bash
+npx witnora connect --server https://witnora.com --project your-project-id
+npx witnora push --evidence .witnora/latest/agentcert-evidence.json
+```
+
+Bind a release, pull-request, or nightly run to an issued continuous assurance
+case by declaring the exact reviewed scope:
+
+```bash
+npx witnora run --config witnora.config.json --push \
+  --assurance-case "$WITNORA_ASSURANCE_CASE_ID" \
+  --assurance-scope agentcert.assurance-scope.json \
+  --assurance-trigger auto \
+  --require-current auto \
+  --continuous-health-out .witnora/canary/generated-kit-health.json
+```
+
+Validate the scope before CI uses it:
+
+```bash
+npx witnora schema validate \
+  --schema assurance-scope \
+  --file agentcert.assurance-scope.json
+```
+
+`auto` treats pull requests as prospective, scheduled workflows as nightly,
+and other GitHub runs as release checks. Authoritative failure or scope drift
+sets the Hosted contract to `REVALIDATION_REQUIRED`; only an independently
+issued successor case establishes a new `CURRENT` baseline.
+Release and nightly checks fail unless Hosted returns `CURRENT`. The optional
+health output is redacted and captures the Hosted run/evidence identifiers,
+evidence completeness, freshness transition, and install-to-CURRENT timing for
+external canaries and operational dashboards.
+
+Add `--push` to `witnora run` to run locally and upload the resulting bundle
+in one command. By default, both commands also upload local files referenced by
+the bundle. Reads are confined to `--artifact-root` (the current directory by
+default), path and symlink escapes are rejected, and uploads are capped at 25
+files, 10 MiB per file, and 50 MiB total. Skipped references are reported in
+the CLI and hosted run timeline. Companion uploads are restricted to
+PNG/JPEG/WebP, JSON/JSONL, HTML, PDF, and ZIP; other extensions are skipped
+before they are read. Pass `--no-artifacts` to upload only the JSON bundle.
+Hosted pushes embed an `agentcert.artifact_manifest.v0.1` declaration with the
+normalized path, SHA-256 digest, byte size, and kind of every prepared
+companion artifact. The control plane reports `complete` only after every
+hosted object exactly matches that declaration; missing, skipped, undeclared,
+or mismatched artifacts remain observable as `partial` or `rejected`.
+Project API keys can create runs, record events, and upload evidence, but
+cannot approve their own runtime actions.
+
+## Customer-owned browser gateway
+
+Generate and certify a sandbox-only credential-isolated browser adapter:
+
+```bash
+npx witnora browser-adapter init
+npx witnora browser-adapter certify --adapter ./agentcert.browser-adapter.mjs
+```
+
+The adapter imports `agentcert/browser-adapter-kit`, keeps write and read-only
+credentials in separate customer callbacks, and writes a digest-only report.
+It rejects production actions. See the
+[two-hour onboarding guide](https://github.com/Kakarottoooo/agentcert/blob/main/docs/customer-owned-browser-adapter.md).
+
+## Sandbox onboarding
+
+Create and certify a synthetic SandboxSystem adapter with the same public CLI:
+
+```bash
+npx witnora sandbox init
+npx witnora sandbox certify --adapter ./agentcert.sandbox.mjs
+```
+
+The first command writes one dependency-free JavaScript file. The second runs
+the bundled deterministic adapter contract and writes
+`.witnora/sandbox/sandbox-adapter-conformance.json`. No `@agentcert` scoped
+package is required.
+
+After `agentcert connect`, certify and upload in one command:
+
+```bash
+npx witnora sandbox push --adapter ./agentcert.sandbox.mjs
+```
+
+Passing and failing reports are both retained for review, while failed
+certifications return a non-zero exit status. The generated template is
+synthetic and network-denied; it must not contain production credentials or
+connect to live systems.
+
+Run one bounded read against an existing Stripe sandbox PaymentIntent:
+
+```bash
+STRIPE_RESTRICTED_TEST_KEY="rk_test_..." npx witnora sandbox stripe-readonly --payment-intent pi_...
+```
+
+Add `--push` to retain the redacted report in Witnora Hosted. The command
+allows only `https://api.stripe.com`, `GET`, and allowlisted PaymentIntent
+routes, with a 5-second timeout and 10-request-per-minute process-local cap.
+The Stripe key is environment-only and is never written to output or evidence.
+See the [Bounded Vendor Sandbox Egress guide](https://github.com/Kakarottoooo/agentcert/blob/main/docs/bounded-vendor-sandbox-egress.md).
+
+Release maintainers can run the protected, manual
+`Real Stripe sandbox acceptance` GitHub workflow. It performs the bounded read,
+independently scans the generated report before upload, validates it again at
+the CLI boundary, uploads the v0.4 evidence, and compares it with prior
+protected runs. See the [real vendor acceptance guide](https://github.com/Kakarottoooo/agentcert/blob/main/docs/real-vendor-acceptance.md).
+
+The workflow's upload step is also available as a narrow command for an
+already-generated report:
 
 ```bash
-npx witnora try --template workflow
+npx witnora sandbox upload-report --report .witnora/vendor-sandbox/current-report.json --external-id vendor-acceptance:stripe:<run>:<attempt>
 ```
 
-This package is intentionally a thin, version-locked bridge to `agentcert`,
-the historical package name. Both commands execute the same maintained CLI:
+This command accepts only Witnora sandbox conformance and vendor-egress
+contracts and rejects reports containing credential-shaped values or forbidden
+sensitive fields.
+
+Review/export helpers:
 
 ```bash
-npx witnora --help
-npx --package agentcert witnora --help
-npx agentcert --help
+npx witnora corpus metrics --corpus .witnora/corpus/corpus.jsonl
+npx witnora corpus export-reviewed --corpus .witnora/corpus/corpus.jsonl --out .witnora/latest/reviewed-failure-dataset.jsonl
+npx witnora corpus classifier-eval --corpus .witnora/corpus/corpus.jsonl --out .witnora/latest/failure-classifier-evaluation.json
+npx witnora validate .witnora/latest/agentcert-evidence.json
+npx witnora validate .witnora/latest/agentcert-evidence.json --check-artifacts
+npx witnora release-gate --config witnora.config.json --strict
+npx witnora release-gate --evidence .witnora/latest/agentcert-evidence.json --baseline .witnora/baselines/main.json
+npx witnora schema validate --schema evidence-bundle --file .witnora/latest/agentcert-evidence.json
+npx witnora schema validate --schema classifier-eval --file examples/agentcert/classifier-eval.example.json
 ```
 
-The legacy package and command remain supported during the migration. New
-integrations should use `witnora`, `WITNORA_*` environment variables, and
-[witnora.com](https://witnora.com/).
+The release gate writes fixed JSON, HTML, Markdown, JUnit, and badge outputs,
+records SHA-256 artifact provenance, and supports optional Ed25519 signatures:
+
+```bash
+npx witnora evidence keygen --private-key .witnora/keys/evidence-private.pem --public-key .witnora/keys/evidence-public.pem
+npx witnora evidence sign .witnora/latest/agentcert-evidence.json --private-key .witnora/keys/evidence-private.pem
+```
 
-Witnora provides evidence and assurance for autonomous AI systems. It does
-not claim to be an official certification authority.
+Control semantics and attestation format:
+[release gate checklist](https://github.com/Kakarottoooo/agentcert/blob/main/docs/release-gate-checklist.md).
+
+CI users can run Tripwire and Witnora together with
+`Kakarottoooo/agentcert/actions/tripwire@v0`.
+
+The public Real Agent Robustness Lab compares browser-use, Stagehand, and
+Playwright-based agents over the same fault suite:
+
+https://kakarottoooo.github.io/agentcert/public-demo/real-agent-robustness/
+
+Minimal no-key browser-agent example in the GitHub repo:
+
+```text
+examples/minimal-browser-agent/
+```
+
+External integration smoke matrix in the GitHub repo:
+
+```text
+examples/real-agents/external-integration-smokes.md
+```
+
+Corpus storage:
+
+```bash
+npx witnora corpus ingest --tripwire .tripwire/latest/tripwire-result.json --out .witnora/corpus/corpus.jsonl --subject my-browser-agent
+npx witnora corpus ingest --store sqlite --sqlite .witnora/corpus/agentcert.sqlite --tripwire .tripwire/latest/tripwire-result.json --subject my-browser-agent
+npx witnora monitor build --store postgres --database-url "$WITNORA_DATABASE_URL" --out .witnora/latest/monitor.json --subject my-browser-agent
+```
+
+The UI always reads `agentcert.monitor_snapshot`, so switching from JSONL to
+SQLite or Postgres does not require a frontend rewrite.
+
+Failure taxonomy reviews:
+
+```bash
+node packages/witnora-cli/dist/cli.js corpus review \
+  --corpus .witnora/corpus/corpus.jsonl \
+  --reviews .witnora/corpus/failure-reviews.jsonl \
+  --pattern-key "tripwire:network_failure:http-failure:no_console_error" \
+  --type console_error \
+  --status corrected \
+  --reviewer qa@example.com \
+  --confidence 0.85 \
+  --first-divergence "Console displayed a 503 failure before the task completed." \
+  --screenshot "runs/http-failure/step-2.png" \
+  --trace "runs/http-failure/trace.json" \
+  --why "The failed assertion is about a browser console error." \
+  --signal "assertion type no_console_error"
+```
+
+The review command appends an `agentcert.failure_review` JSONL record, reapplies
+the review ledger, and writes the corrected taxonomy back to the corpus store.
+Optional review metadata includes confidence, first-divergence snippets,
+screenshot/trace pointers, supporting signals, classifier limitations, and a
+structured taxonomy rationale for later classifier training and evaluation.
+
+For local development inside this repository:
+
+```bash
+npm --prefix packages/witnora-cli ci
+npm --prefix packages/witnora-cli run build
+node packages/witnora-cli/dist/cli.js run --profile public-demo
+```

package/dist/artifact-manifest.js

@@ -0,0 +1,37 @@
+import { createHash } from "node:crypto";
+import { AGENTCERT_ARTIFACT_MANIFEST_VERSION, } from "./types.js";
+export function buildArtifactManifest(artifacts) {
+    const entries = artifacts.map((artifact) => ({
+        path: normalizeManifestPath(artifact.sourcePath),
+        sha256: createHash("sha256").update(artifact.bytes).digest("hex"),
+        sizeBytes: artifact.bytes.byteLength,
+        kind: artifact.kind,
+    })).sort((left, right) => left.path.localeCompare(right.path));
+    const paths = new Set();
+    for (const entry of entries) {
+        if (paths.has(entry.path))
+            throw new Error(`Artifact manifest contains duplicate path ${entry.path}.`);
+        paths.add(entry.path);
+    }
+    return { schemaVersion: AGENTCERT_ARTIFACT_MANIFEST_VERSION, entries };
+}
+export function withArtifactManifest(bundle, artifacts) {
+    return { ...bundle, artifactManifest: buildArtifactManifest(artifacts) };
+}
+export function serializeHostedEvidenceBundle(bundle, artifacts) {
+    const reconciledBundle = withArtifactManifest(bundle, artifacts);
+    return {
+        bundle: reconciledBundle,
+        bytes: new TextEncoder().encode(`${JSON.stringify(reconciledBundle, null, 2)}\n`),
+    };
+}
+export function normalizeManifestPath(value) {
+    const path = value.replace(/\\/g, "/").replace(/^\.\//, "").trim();
+    if (!path || path.length > 1024 || path.startsWith("/") || /^[A-Za-z]:\//.test(path)) {
+        throw new Error(`Artifact manifest path must be a relative path: ${value}`);
+    }
+    if (path.split("/").some((segment) => segment === ".." || segment === "")) {
+        throw new Error(`Artifact manifest path cannot contain empty or parent segments: ${value}`);
+    }
+    return path;
+}

package/dist/artifact-validation.js

@@ -0,0 +1,102 @@
+import { access } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+export async function validateEvidenceArtifacts(input, artifactRoot) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        return { checked: 0, missing: [] };
+    }
+    const uniquePaths = collectEvidenceArtifactPaths(input, artifactRoot)
+        .filter((entry) => !isRemoteArtifactPath(entry.sourcePath));
+    const missing = [];
+    for (const entry of uniquePaths) {
+        const fullPath = isAbsolute(entry.sourcePath) ? entry.sourcePath : resolve(entry.root, entry.sourcePath);
+        try {
+            await access(fullPath);
+        }
+        catch {
+            missing.push(entry.sourcePath);
+        }
+    }
+    return { checked: uniquePaths.length, missing };
+}
+export function collectEvidenceArtifactPaths(input, artifactRoot) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return [];
+    const bundle = input;
+    const paths = [];
+    const productRoots = productArtifactRoots(bundle, artifactRoot);
+    collectStringValues(bundle.artifacts, paths, artifactRoot);
+    const results = Array.isArray(bundle.results) ? bundle.results : [];
+    for (const result of results) {
+        if (result && typeof result === "object" && !Array.isArray(result)) {
+            const resultRecord = result;
+            collectStringValues(resultRecord.artifacts, paths, artifactRoot);
+            const product = typeof resultRecord.product === "string" ? resultRecord.product : undefined;
+            collectEvidencePaths(resultRecord.evidence, paths, product ? (productRoots.get(product) ?? artifactRoot) : artifactRoot);
+        }
+    }
+    collectEvidencePaths(bundle.evidence, paths, artifactRoot, productRoots);
+    return dedupeArtifactPathEntries(paths);
+}
+function collectEvidencePaths(input, paths, root, productRoots) {
+    const evidence = Array.isArray(input) ? input : [];
+    for (const item of evidence) {
+        if (item && typeof item === "object" && !Array.isArray(item)) {
+            const itemRecord = item;
+            const artifactPath = itemRecord.artifactPath;
+            if (typeof artifactPath === "string" && artifactPath.length > 0) {
+                const source = typeof itemRecord.source === "string" ? itemRecord.source : undefined;
+                paths.push({ sourcePath: artifactPath, root: source && productRoots ? (productRoots.get(source) ?? root) : root });
+            }
+        }
+    }
+}
+function productArtifactRoots(bundle, artifactRoot) {
+    const roots = new Map();
+    const results = Array.isArray(bundle.results) ? bundle.results : [];
+    for (const result of results) {
+        if (!result || typeof result !== "object" || Array.isArray(result))
+            continue;
+        const resultRecord = result;
+        const product = resultRecord.product;
+        const artifacts = resultRecord.artifacts;
+        if (typeof product !== "string" || !artifacts || typeof artifacts !== "object" || Array.isArray(artifacts))
+            continue;
+        const artifactRecord = artifacts;
+        const outDir = artifactRecord.outDir;
+        const resultPath = artifactRecord.result ?? artifactRecord.results;
+        if (typeof outDir === "string" && outDir.length > 0) {
+            roots.set(product, isAbsolute(outDir) ? outDir : resolve(artifactRoot, outDir));
+        }
+        else if (typeof resultPath === "string" && resultPath.length > 0) {
+            roots.set(product, dirname(isAbsolute(resultPath) ? resultPath : resolve(artifactRoot, resultPath)));
+        }
+    }
+    return roots;
+}
+function collectStringValues(input, paths, root) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        return;
+    }
+    for (const [name, value] of Object.entries(input)) {
+        if (name === "outDir" || name.endsWith(".outDir"))
+            continue;
+        if (typeof value === "string" && value.length > 0) {
+            paths.push({ sourcePath: value, root });
+        }
+    }
+}
+function dedupeArtifactPathEntries(entries) {
+    const seen = new Set();
+    const deduped = [];
+    for (const entry of entries) {
+        const key = `${entry.root}\0${entry.sourcePath}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(entry);
+    }
+    return deduped;
+}
+export function isRemoteArtifactPath(value) {
+    return /^[a-z][a-z0-9+.-]*:\/\//i.test(value);
+}

package/dist/badge.js

@@ -0,0 +1,31 @@
+export function renderAgentCertBadge(bundle) {
+    const status = bundle.verdict.passed ? "pass" : "fail";
+    const color = bundle.verdict.passed ? "#087f5b" : "#cc2431";
+    const value = `${status} ${bundle.verdict.score}`;
+    const valueWidth = Math.max(54, value.length * 7 + 18);
+    const labelWidth = 66;
+    const width = labelWidth + valueWidth;
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="20" role="img" aria-label="witnora: ${escapeXml(value)}">
+  <title>witnora: ${escapeXml(value)}</title>
+  <linearGradient id="s" x2="0" y2="100%">
+    <stop offset="0" stop-color="#fff" stop-opacity=".12"/>
+    <stop offset="1" stop-color="#000" stop-opacity=".12"/>
+  </linearGradient>
+  <clipPath id="r"><rect width="${width}" height="20" rx="3" fill="#fff"/></clipPath>
+  <g clip-path="url(#r)">
+    <rect width="${labelWidth}" height="20" fill="#07172f"/>
+    <rect x="${labelWidth}" width="${valueWidth}" height="20" fill="${color}"/>
+    <rect width="${width}" height="20" fill="url(#s)"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
+    <text x="${labelWidth / 2}" y="15" fill="#010101" fill-opacity=".3">witnora</text>
+    <text x="${labelWidth / 2}" y="14">witnora</text>
+    <text x="${labelWidth + valueWidth / 2}" y="15" fill="#010101" fill-opacity=".3">${escapeXml(value)}</text>
+    <text x="${labelWidth + valueWidth / 2}" y="14">${escapeXml(value)}</text>
+  </g>
+</svg>
+`;
+}
+function escapeXml(value) {
+    return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}

package/dist/browser-adapter.js

@@ -0,0 +1,156 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+const DEFAULT_ADAPTER_PATH = "witnora.browser-adapter.mjs";
+const DEFAULT_REPORT_PATH = ".witnora/browser-adapter/conformance.json";
+export async function runBrowserAdapterCommand(args) {
+    const action = args[0] ?? "help";
+    if (action === "help" || args.includes("--help") || args.includes("-h")) {
+        process.stdout.write(renderBrowserAdapterHelp(action === "help" ? undefined : action));
+        return { exitCode: 0 };
+    }
+    if (action === "init")
+        return initializeBrowserAdapter(args.slice(1));
+    if (action === "certify")
+        return certifyBrowserAdapter(args.slice(1));
+    throw new Error(`Unknown browser-adapter command ${JSON.stringify(action)}. Run \`npx witnora browser-adapter --help\`.`);
+}
+export async function initializeBrowserAdapter(args) {
+    const requestedPath = flag(args, "--adapter") ?? flag(args, "--out") ?? DEFAULT_ADAPTER_PATH;
+    const outPath = resolve(requestedPath);
+    await writeStarterFile(outPath, browserAdapterTemplate(), args.includes("--force"));
+    process.stdout.write(`Wrote ${outPath}\n\nNext:\n  npx witnora browser-adapter certify --adapter ${JSON.stringify(requestedPath)}\n`);
+    process.stdout.write("\nThe generated adapter is synthetic and sandbox-only. Replace its callbacks with your customer-owned sandbox boundary before pilot use.\n");
+    return { exitCode: 0 };
+}
+export async function certifyBrowserAdapter(args, runtimeOverride, adapterOverride) {
+    const runtime = runtimeOverride ?? await loadRuntime();
+    const adapterPath = resolve(flag(args, "--adapter") ?? DEFAULT_ADAPTER_PATH);
+    const adapterModule = adapterOverride ?? await loadAdapter(adapterPath);
+    const kit = adapterModule.browserAdapterKit
+        ?? runtime.createCustomerOwnedBrowserAdapterKit(adapterModule.browserAdapterConfig);
+    const report = await runtime.runCustomerOwnedBrowserAdapterConformance({
+        kit,
+        fixture: adapterModule.browserAdapterFixture,
+    });
+    const reportPath = resolve(flag(args, "--out") ?? DEFAULT_REPORT_PATH);
+    await mkdir(dirname(reportPath), { recursive: true });
+    await writeFile(reportPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+    process.stdout.write(`${report.verdict.passed ? "PASS" : "FAIL"} ${report.verdict.score}/100 customer-owned browser adapter conformance\n`);
+    for (const check of report.checks)
+        process.stdout.write(`- ${check.status === "passed" ? "PASS" : "FAIL"} ${check.id}: ${check.message}\n`);
+    process.stdout.write(`Report: ${reportPath}\n`);
+    return { exitCode: report.verdict.passed ? 0 : 1, reportPath, report };
+}
+export function renderBrowserAdapterHelp(action) {
+    if (action === "init")
+        return `Usage:\n  witnora browser-adapter init [--adapter witnora.browser-adapter.mjs] [--force]\n\nWrites a safe, customer-owned browser sandbox adapter template.\n`;
+    if (action === "certify")
+        return `Usage:\n  witnora browser-adapter certify --adapter ./witnora.browser-adapter.mjs [--out .witnora/browser-adapter/conformance.json]\n\nChecks the gateway boundary, allowlists, credential separation, outcome probe, target audit match, revocation, and report redaction.\n`;
+    return `Usage:\n  witnora browser-adapter init [--adapter witnora.browser-adapter.mjs]\n  witnora browser-adapter certify --adapter ./witnora.browser-adapter.mjs\n\nCommands:\n  init      Write a sandbox-only adapter and deterministic fixture\n  certify   Run local boundary and evidence conformance\n`;
+}
+async function loadRuntime() {
+    try {
+        return await import(new URL("./vendor/onegent-runtime/browser-adapter-kit.js", import.meta.url).href);
+    }
+    catch (error) {
+        const code = error && typeof error === "object" && "code" in error ? String(error.code) : undefined;
+        if (code === "ERR_MODULE_NOT_FOUND")
+            throw new Error("Witnora browser adapter runtime is missing. Reinstall agentcert and retry.");
+        throw error;
+    }
+}
+async function loadAdapter(adapterPath) {
+    let module;
+    try {
+        module = await import(pathToFileURL(adapterPath).href);
+    }
+    catch (error) {
+        throw new Error(`Could not load browser adapter ${adapterPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const hasKit = isRecord(module.browserAdapterKit) && typeof module.browserAdapterKit.prepareExecution === "function";
+    if ((!hasKit && !isRecord(module.browserAdapterConfig)) || !isRecord(module.browserAdapterFixture)) {
+        throw new Error(`${adapterPath} must export browserAdapterConfig (or a legacy browserAdapterKit) and browserAdapterFixture.`);
+    }
+    return module;
+}
+function browserAdapterTemplate() {
+    return `// Safe starter: local synthetic sandbox state. Never point v0.1 at production.
+const WRITE_SECRET = process.env.BROWSER_SANDBOX_WRITE_KEY ?? "synthetic-write-credential";
+const READ_SECRET = process.env.BROWSER_SANDBOX_READ_KEY ?? "synthetic-read-credential";
+let state = { status: "DRAFT", reference: "ORDER-DEMO-1" };
+const audit = [];
+const parametersDigest = "fixture-parameters-sha256";
+
+export const browserAdapterConfig = {
+  name: "customer-browser-sandbox",
+  targetSystem: "CustomerBrowserSandbox",
+  allowedOrigins: ["https://sandbox.example.test"],
+  allowedActionTypes: ["SUBMIT"],
+  allowedOperation: "order.submit",
+  allowedResource: "order:ORDER-DEMO-1",
+  sandbox: true,
+  resolveWriteCredential() {
+    return { reference: "secret-provider://browser/write", secret: WRITE_SECRET, expiresAt: futureExpiry() };
+  },
+  resolveReadCredential() {
+    return { reference: "secret-provider://browser/read", secret: READ_SECRET, expiresAt: futureExpiry() };
+  },
+  execute({ action, context, credential }) {
+    if (credential !== WRITE_SECRET) throw new Error("Write credential boundary failed.");
+    const previousState = structuredClone(state);
+    state = structuredClone(action.proposedAfterState);
+    audit.splice(0, audit.length, {
+      targetEventId: "audit-1", actionId: action.id, executionSessionId: context.idempotencyKey,
+      occurredAt: new Date().toISOString(), operation: "order.submit", resource: "order:ORDER-DEMO-1",
+      parametersDigest, credentialReferenceDigest: "write-reference-digest",
+    });
+    return { method: "LOCAL_ADAPTER", targetSystem: action.targetSystem, previousState, observedState: structuredClone(state) };
+  },
+  observe({ credential }) {
+    if (credential !== READ_SECRET) throw new Error("Read credential boundary failed.");
+    return { observationId: "observation-1", observedAt: new Date().toISOString(), observedState: structuredClone(state), source: "customer-sandbox-read-api" };
+  },
+  listAuditEvents({ credential }) {
+    if (credential !== READ_SECRET) throw new Error("Audit credential boundary failed.");
+    return structuredClone(audit);
+  },
+  revokeWriteCredential() {},
+};
+
+export const browserAdapterFixture = {
+  action: {
+    id: "action-demo-1", idempotencyKey: "adapter-demo-1", workspaceId: "local", workflowId: "browser-adapter-conformance",
+    sourceAgentName: "customer-browser-agent", principal: { id: "customer-browser-agent", type: "agent", version: "1.0.0" },
+    requestedPermissions: ["order.submit"], actionType: "SUBMIT", targetSystem: "CustomerBrowserSandbox",
+    targetUrl: "https://sandbox.example.test/orders/ORDER-DEMO-1", environment: "staging", title: "Submit sandbox order",
+    description: "Conformance-only synthetic order submission.", businessObjectType: "order", businessObjectId: "ORDER-DEMO-1",
+    beforeState: { status: "DRAFT", reference: "ORDER-DEMO-1" }, proposedAfterState: { status: "SUBMITTED", reference: "ORDER-DEMO-1" },
+    fieldsChanged: [{ field: "status", before: "DRAFT", after: "SUBMITTED" }], createdAt: new Date().toISOString(), status: "APPROVED",
+  },
+  expectedObservedState: { status: "SUBMITTED", reference: "ORDER-DEMO-1" },
+  expectedAudit: { operation: "order.submit", resource: "order:ORDER-DEMO-1", parametersDigest },
+  forbiddenSecrets: [WRITE_SECRET, READ_SECRET],
+};
+
+function futureExpiry() { return new Date(Date.now() + 10 * 60_000).toISOString(); }
+`;
+}
+function flag(args, name) {
+    const index = args.indexOf(name);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+async function writeStarterFile(path, content, force) {
+    await mkdir(dirname(path), { recursive: true });
+    try {
+        await writeFile(path, content, { flag: force ? "w" : "wx" });
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "EEXIST")
+            throw new Error(`${path} already exists. Re-run with --force to overwrite it.`);
+        throw error;
+    }
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}