@aarmos/bridge 0.1.10 → 0.1.11

package/dist/index.js

@@ -1,240 +1,1521 @@
 #!/usr/bin/env node
+#!/usr/bin/env node
+import {
+  createSession,
+  handleRpc,
+  startBridge
+} from "./chunk-GMH5B5YX.js";
+
+// src/index.ts
 import { Command } from "commander";
-import { startDev } from "./commands/dev.js";
-import { runDemo } from "./commands/demo.js";
-import { startRun } from "./commands/run.js";
-import { runSimulate } from "./commands/simulate.js";
-import { playbookKeygen, playbookSign, playbookVerify } from "./commands/playbook.js";
-import { packInstall, packList, packVerify } from "./commands/pack.js";
-import { runAttest, runAttestVerify } from "./commands/attest.js";
-const program = new Command();
-program
-    .name("aarmos")
-    .description("Aarmos CLI bridge — native host for the Aarmos PWA")
-    .version("0.0.0-dev");
-// Repeatable-option collector. Commander calls the coerce function once per
-// occurrence with the previous accumulator as the second arg.
-function collect(value, prev) {
-    return [...prev, value];
-}
-program
-    .command("dev")
-    .description("Start the local bridge and pair with the PWA")
-    .option("-p, --port <port>", "WebSocket port to bind on 127.0.0.1", "7423")
-    .option("--pwa <url>", "PWA base URL to open for pairing", process.env.AARMOS_PWA_URL ?? "https://www.aarmos.io")
-    .option("--no-open", "Do not auto-open the PWA in the browser")
-    .option("--allow-shell <bins>", "Comma-separated additional shell binaries to allow (in addition to defaults)", "")
-    .option("--allow-sql <alias=dsn>", "Register a read-only Postgres target. Repeatable. Example: --allow-sql prod=postgres://readonly@…/db", collect, [])
-    .option("--allow-read <path>", "Allow fs.scopedRead / fs.scopedList inside this absolute path (outside the workspace). Repeatable.", collect, [])
-    .action(async (opts) => {
-    const sqlAllow = opts.allowSql.map((raw) => {
-        const eq = raw.indexOf("=");
-        if (eq < 0) {
-            throw new Error(`--allow-sql expects <alias>=<dsn>, got: ${raw}`);
+
+// src/commands/dev.ts
+import crypto from "crypto";
+import path from "path";
+import open from "open";
+async function startDev(opts) {
+  const workspace = path.resolve(process.cwd());
+  const pairingToken = crypto.randomBytes(24).toString("base64url");
+  const { port, url: wsUrl } = await startBridge({
+    port: opts.port,
+    workspace,
+    pairingToken,
+    extraShellAllow: opts.extraShellAllow,
+    sqlAllow: opts.sqlAllow,
+    readAllow: opts.readAllow,
+    allowedOrigins: buildAllowedOrigins(opts.pwaUrl)
+  });
+  const pairUrl = new URL(opts.pwaUrl);
+  pairUrl.searchParams.set("bridge", "1");
+  pairUrl.searchParams.set("port", String(port));
+  pairUrl.searchParams.set("token", pairingToken);
+  console.log(`
+  aarmos bridge ready`);
+  console.log(`    workspace : ${workspace}`);
+  console.log(`    ws        : ${wsUrl}`);
+  if (opts.sqlAllow.length > 0) {
+    console.log(`    sql       : ${opts.sqlAllow.map((s) => s.alias).join(", ")} (read-only)`);
+  }
+  if (opts.readAllow.length > 0) {
+    console.log(`    read      : ${opts.readAllow.join(", ")}`);
+  }
+  console.log(`    pair url  : ${pairUrl.toString()}
+`);
+  if (opts.autoOpen) {
+    try {
+      await open(pairUrl.toString());
+    } catch {
+      console.warn("[aarmos] could not auto-open browser; paste the pair url above");
+    }
+  }
+}
+function buildAllowedOrigins(pwaUrl) {
+  const url = new URL(pwaUrl);
+  const set = /* @__PURE__ */ new Set([url.origin]);
+  set.add("https://www.aarmos.io");
+  set.add("http://localhost:8080");
+  set.add("http://127.0.0.1:8080");
+  return [...set];
+}
+
+// src/commands/demo.ts
+import path2 from "path";
+import fs from "fs/promises";
+async function runDemo(opts) {
+  const workspace = path2.resolve(opts.workspace ?? process.cwd());
+  const session = createSession({ workspace, extraShellAllow: [] });
+  log("");
+  log(`  aarmos demo`);
+  log(`    workspace : ${workspace}`);
+  log(
+    `    mode      : ${opts.apply ? "PREVIEW + APPLY" : "PREVIEW ONLY (pass --apply to commit)"}`
+  );
+  log("");
+  await ensureSampleFiles(workspace);
+  const todoPath = "notes/todo.md";
+  const existingTodo = await safeRead(path2.join(workspace, todoPath));
+  const newTodo = (existingTodo ?? "# Todo\n\n") + `- [ ] Added by \`aarmos demo\` at ${(/* @__PURE__ */ new Date()).toISOString()}
+`;
+  const proposals = [
+    {
+      label: "Append a checklist item to notes/todo.md",
+      method: "fs.write",
+      params: { path: todoPath, data: newTodo, encoding: "utf8" }
+    },
+    {
+      label: "Inspect the workspace with `git status`",
+      method: "shell.exec",
+      params: { bin: "git", args: ["status", "--short"], cwd: "." }
+    },
+    {
+      label: "Say hello via `node src/hello.js aarmos`",
+      method: "shell.exec",
+      params: { bin: "node", args: ["src/hello.js", "aarmos"], cwd: "." }
+    }
+  ];
+  log("  proposed batch (dry-run previews):");
+  log("");
+  const collected = [];
+  for (let i = 0; i < proposals.length; i++) {
+    const p = proposals[i];
+    const res = await call(session, p.method, p.params);
+    log(`  [${i + 1}] ${p.label}`);
+    if (isPreview(res)) {
+      renderPreview(res.action);
+      collected.push({ kind: res.action.kind, params: res.action.params });
+    } else {
+      log(`      (no preview) ${JSON.stringify(res)}`);
+    }
+    log("");
+  }
+  if (!opts.apply) {
+    log("  nothing was written. rerun with --apply to commit the batch.");
+    log("");
+    return;
+  }
+  log("  applying batch via apply.batch \u2026");
+  const applyRes = await call(session, "apply.batch", { actions: collected });
+  log(`  applied ${applyRes.applied}/${collected.length} action(s):`);
+  applyRes.results.forEach((r, i) => {
+    if (r.ok) {
+      log(`    \u2713 [${i + 1}] ${r.kind}`);
+      if (r.kind === "shell.exec" && r.result && typeof r.result === "object") {
+        const sh = r.result;
+        if (sh.stdout?.trim()) indented(sh.stdout.trim());
+        if (sh.stderr?.trim()) indented(sh.stderr.trim());
+      }
+    } else {
+      log(`    \u2717 [${i + 1}] ${r.kind}: ${r.error}`);
+    }
+  });
+  log("");
+}
+function isPreview(x) {
+  return !!x && typeof x === "object" && x.preview === true;
+}
+async function call(session, method, params) {
+  const res = await handleRpc(session, { id: 1, type: "rpc", method, params });
+  if ("type" in res && res.type === "error") throw new Error(res.error);
+  if ("type" in res && res.type === "result") return res.result;
+  throw new Error("unexpected rpc envelope");
+}
+function renderPreview(action) {
+  const pv = action.preview;
+  if (action.kind === "fs.write") {
+    const before = String(pv.before ?? "");
+    const after = String(pv.after ?? "");
+    log(`      path      : ${pv.path}`);
+    log(`      existed   : ${pv.existed}   bytes: ${pv.bytesBefore} \u2192 ${pv.bytesAfter}`);
+    log(`      diff      :`);
+    for (const line of unifiedDiff(before, after)) log(`        ${line}`);
+  } else {
+    log(`      command   : ${pv.commandLine}`);
+    log(`      cwd       : ${pv.cwd}`);
+  }
+}
+function unifiedDiff(before, after) {
+  const a = before.split("\n");
+  const b = after.split("\n");
+  const out = [];
+  const max = Math.max(a.length, b.length);
+  for (let i = 0; i < max; i++) {
+    if (a[i] === b[i]) {
+      if (a[i] !== void 0) out.push(`  ${a[i]}`);
+    } else {
+      if (a[i] !== void 0) out.push(`- ${a[i]}`);
+      if (b[i] !== void 0) out.push(`+ ${b[i]}`);
+    }
+  }
+  return out;
+}
+async function safeRead(abs) {
+  try {
+    return await fs.readFile(abs, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function ensureSampleFiles(workspace) {
+  const todo = path2.join(workspace, "notes/todo.md");
+  try {
+    await fs.access(todo);
+  } catch {
+    await fs.mkdir(path2.dirname(todo), { recursive: true });
+    await fs.writeFile(todo, "# Todo\n\n- [ ] Try the aarmos dry-run demo\n");
+  }
+  const hello = path2.join(workspace, "src/hello.js");
+  try {
+    await fs.access(hello);
+  } catch {
+    await fs.mkdir(path2.dirname(hello), { recursive: true });
+    await fs.writeFile(
+      hello,
+      "const name = process.argv[2] || 'world';\nconsole.log(`hello, ${name} \u2014 from the aarmos sample workspace`);\n"
+    );
+  }
+}
+function log(s) {
+  console.log(s);
+}
+function indented(s) {
+  for (const line of s.split("\n")) log(`         \u2502 ${line}`);
+}
+
+// src/commands/run.ts
+import path6 from "path";
+import fs4 from "fs/promises";
+import fssync from "fs";
+import crypto4 from "crypto";
+
+// src/lib/playbook.ts
+import fs2 from "fs/promises";
+import path3 from "path";
+import crypto2 from "crypto";
+async function loadPlaybook(p) {
+  const raw = await fs2.readFile(path3.resolve(p), "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`playbook is not valid JSON: ${err.message}`);
+  }
+  if (!parsed || typeof parsed !== "object") throw new Error("playbook must be an object");
+  const pb = parsed;
+  if (!pb.name || typeof pb.name !== "string") throw new Error("playbook.name is required");
+  if (!Array.isArray(pb.steps) || pb.steps.length === 0) {
+    throw new Error("playbook.steps must be a non-empty array");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const s of pb.steps) {
+    if (!s.id || typeof s.id !== "string") throw new Error("each step needs an id");
+    if (seen.has(s.id)) throw new Error(`duplicate step id: ${s.id}`);
+    seen.add(s.id);
+    if (s.kind !== "shell.exec" && s.kind !== "fs.write" && s.kind !== "http.call" && s.kind !== "mcp.tool") {
+      throw new Error(
+        `step ${s.id}: kind must be one of shell.exec, fs.write, http.call, mcp.tool`
+      );
+    }
+    if (!s.params || typeof s.params !== "object") {
+      throw new Error(`step ${s.id}: params object required`);
+    }
+  }
+  return pb;
+}
+function lintPlaybook(pb) {
+  const out = [];
+  if (pb.steps.length > 100) {
+    out.push({
+      level: "warn",
+      message: `playbook has ${pb.steps.length} steps \u2014 consider splitting`
+    });
+  }
+  for (const s of pb.steps) {
+    if (!s.label)
+      out.push({ level: "warn", stepId: s.id, message: "missing human-readable label" });
+    if (s.intervalSec !== void 0 && (typeof s.intervalSec !== "number" || s.intervalSec < 1)) {
+      out.push({ level: "error", stepId: s.id, message: "intervalSec must be a positive number" });
+    }
+    if (s.kind === "shell.exec") {
+      const p = s.params;
+      if (typeof p.bin !== "string" || !p.bin) {
+        out.push({
+          level: "error",
+          stepId: s.id,
+          message: "shell.exec: params.bin (string) required"
+        });
+      }
+      if (p.args !== void 0 && !Array.isArray(p.args)) {
+        out.push({
+          level: "error",
+          stepId: s.id,
+          message: "shell.exec: params.args must be an array"
+        });
+      }
+      if (s.autoApply) {
+        out.push({
+          level: "info",
+          stepId: s.id,
+          message: "shell.exec has autoApply=true \u2014 will execute unattended if bin is in allowlist"
+        });
+      }
+    }
+    if (s.kind === "fs.write") {
+      const p = s.params;
+      if (typeof p.path !== "string" || !p.path) {
+        out.push({
+          level: "error",
+          stepId: s.id,
+          message: "fs.write: params.path (string) required"
+        });
+      }
+      if (p.data !== void 0 && typeof p.data !== "string") {
+        out.push({
+          level: "error",
+          stepId: s.id,
+          message: "fs.write: params.data must be a string"
+        });
+      }
+    }
+    if (s.kind === "http.call") {
+      const p = s.params;
+      if (typeof p.url !== "string" || !/^https?:\/\//.test(p.url)) {
+        out.push({
+          level: "error",
+          stepId: s.id,
+          message: "http.call: params.url (http(s) URL) required"
+        });
+      }
+      if (p.method !== void 0 && typeof p.method !== "string") {
+        out.push({
+          level: "error",
+          stepId: s.id,
+          message: "http.call: params.method must be a string"
+        });
+      }
+    }
+    if (s.kind === "mcp.tool") {
+      const p = s.params;
+      if (typeof p.endpoint !== "string" || !/^https?:\/\//.test(p.endpoint)) {
+        out.push({
+          level: "error",
+          stepId: s.id,
+          message: "mcp.tool: params.endpoint (http(s) URL) required"
+        });
+      }
+      if (typeof p.tool !== "string" || !p.tool) {
+        out.push({
+          level: "error",
+          stepId: s.id,
+          message: "mcp.tool: params.tool (string) required"
+        });
+      }
+    }
+  }
+  return out;
+}
+function canonicalize(v) {
+  if (v === void 0) return "null";
+  if (v === null || typeof v !== "object") return JSON.stringify(v);
+  if (Array.isArray(v)) return "[" + v.map((x) => canonicalize(x)).join(",") + "]";
+  const obj = v;
+  const keys = Object.keys(obj).filter((k) => obj[k] !== void 0).sort();
+  return "{" + keys.map((k) => JSON.stringify(k) + ":" + canonicalize(obj[k])).join(",") + "}";
+}
+function playbookBody(pb) {
+  const { signature: _s, ...rest } = pb;
+  void _s;
+  return canonicalize(rest);
+}
+function b64u(buf) {
+  return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function b64uDecode(s) {
+  const b64 = s.replace(/-/g, "+").replace(/_/g, "/") + "===".slice((s.length + 3) % 4);
+  return Buffer.from(b64, "base64");
+}
+async function generateSigningKeyPair(outDir, name) {
+  const { publicKey, privateKey } = crypto2.generateKeyPairSync("ed25519");
+  const pem = privateKey.export({ format: "pem", type: "pkcs8" }).toString();
+  const raw = publicKey.export({ format: "der", type: "spki" });
+  const rawKey = raw.subarray(raw.length - 32);
+  const pubB64u = b64u(rawKey);
+  await fs2.mkdir(outDir, { recursive: true });
+  const privPath = path3.join(outDir, `${name}.key.pem`);
+  const pubPath = path3.join(outDir, `${name}.pub`);
+  await fs2.writeFile(privPath, pem, { mode: 384 });
+  await fs2.writeFile(pubPath, pubB64u + "\n");
+  return { privatePem: privPath, publicKey: pubB64u };
+}
+async function signPlaybook(pb, privateKeyPem) {
+  const key = crypto2.createPrivateKey(privateKeyPem);
+  const bytes = Buffer.from(playbookBody(pb));
+  const sig = crypto2.sign(null, bytes, key);
+  const pubDer = crypto2.createPublicKey(key).export({ format: "der", type: "spki" });
+  const rawPub = pubDer.subarray(pubDer.length - 32);
+  return {
+    ...pb,
+    signature: { alg: "ed25519", pubKey: b64u(rawPub), sig: b64u(sig) }
+  };
+}
+function verifyPlaybookSignature(pb) {
+  if (!pb.signature) return { ok: false, reason: "playbook is not signed" };
+  if (pb.signature.alg !== "ed25519") {
+    return { ok: false, reason: `unsupported alg: ${pb.signature.alg}` };
+  }
+  try {
+    const spkiPrefix = Buffer.from([
+      48,
+      42,
+      48,
+      5,
+      6,
+      3,
+      43,
+      101,
+      112,
+      3,
+      33,
+      0
+    ]);
+    const rawPub = b64uDecode(pb.signature.pubKey);
+    if (rawPub.length !== 32) return { ok: false, reason: "pubKey must be 32 bytes" };
+    const der = Buffer.concat([spkiPrefix, rawPub]);
+    const key = crypto2.createPublicKey({ key: der, format: "der", type: "spki" });
+    const bytes = Buffer.from(playbookBody(pb));
+    const sig = b64uDecode(pb.signature.sig);
+    const ok = crypto2.verify(null, bytes, key, sig);
+    return ok ? { ok: true } : { ok: false, reason: "signature does not match playbook body" };
+  } catch (err) {
+    return { ok: false, reason: err.message };
+  }
+}
+function hashPlaybook(pb) {
+  return crypto2.createHash("sha256").update(playbookBody(pb)).digest("hex");
+}
+async function writePlaybook(p, pb) {
+  await fs2.writeFile(path3.resolve(p), JSON.stringify(pb, null, 2) + "\n", "utf8");
+}
+
+// src/lib/scope-templates.ts
+var KUBECTL_READ = /* @__PURE__ */ new Set([
+  "get",
+  "describe",
+  "logs",
+  "top",
+  "version",
+  "api-resources",
+  "api-versions",
+  "explain",
+  "config",
+  "cluster-info",
+  "auth"
+]);
+var KUBECTL_WRITE = /* @__PURE__ */ new Set([
+  "apply",
+  "create",
+  "scale",
+  "patch",
+  "rollout",
+  "edit",
+  "label",
+  "annotate",
+  "set",
+  "expose",
+  "run",
+  "autoscale",
+  "replace",
+  "taint"
+]);
+var KUBECTL_DESTRUCTIVE = /* @__PURE__ */ new Set(["delete", "drain", "cordon", "uncordon", "evict", "exec"]);
+var GIT_DESTRUCTIVE_FLAGS = ["--force", "-f", "--hard", "-D"];
+var GIT_DESTRUCTIVE_SUBCMDS = /* @__PURE__ */ new Set(["push", "reset", "clean", "branch", "rebase"]);
+var GH_READ = /* @__PURE__ */ new Set(["view", "list", "status", "search", "browse", "auth"]);
+var GH_DESTRUCTIVE = /* @__PURE__ */ new Set(["delete", "close"]);
+function httpRisk(method) {
+  const m = method.toUpperCase();
+  if (m === "GET" || m === "HEAD" || m === "OPTIONS") return "read";
+  if (m === "DELETE") return "destructive";
+  return "write";
+}
+function classifyStep(step) {
+  const p = step.params;
+  const explicit = step.risk;
+  if (explicit) return { rank: explicit, reason: "explicit step.risk override" };
+  if (step.kind === "fs.write") {
+    return { rank: "write", reason: "fs.write mutates workspace" };
+  }
+  if (step.kind === "shell.exec") {
+    const bin = String(p.bin ?? "");
+    const args = Array.isArray(p.args) ? p.args : [];
+    if (bin === "kubectl") {
+      const sub = args.find((a) => !a.startsWith("-")) ?? "";
+      if (KUBECTL_DESTRUCTIVE.has(sub)) {
+        return { rank: "destructive", reason: `kubectl ${sub}`, template: "kubectl" };
+      }
+      if (KUBECTL_WRITE.has(sub)) {
+        return { rank: "write", reason: `kubectl ${sub}`, template: "kubectl" };
+      }
+      if (KUBECTL_READ.has(sub)) {
+        return { rank: "read", reason: `kubectl ${sub}`, template: "kubectl" };
+      }
+      return {
+        rank: "write",
+        reason: `kubectl ${sub || "(unknown)"} \u2014 defaulted`,
+        template: "kubectl"
+      };
+    }
+    if (bin === "git") {
+      const sub = args.find((a) => !a.startsWith("-")) ?? "";
+      const hasForce = args.some((a) => GIT_DESTRUCTIVE_FLAGS.includes(a));
+      if (GIT_DESTRUCTIVE_SUBCMDS.has(sub) && hasForce) {
+        return { rank: "destructive", reason: `git ${sub} with force flag`, template: "git" };
+      }
+      if (sub === "push") return { rank: "write", reason: "git push", template: "git" };
+      if (sub === "commit" || sub === "add" || sub === "checkout") {
+        return { rank: "write", reason: `git ${sub}`, template: "git" };
+      }
+      return { rank: "read", reason: `git ${sub || "status"}`, template: "git" };
+    }
+    if (bin === "gh") {
+      const sub = args.find((a) => !a.startsWith("-")) ?? "";
+      if (GH_DESTRUCTIVE.has(sub)) {
+        return { rank: "destructive", reason: `gh ${sub}`, template: "gh" };
+      }
+      if (GH_READ.has(sub)) return { rank: "read", reason: `gh ${sub}`, template: "gh" };
+      return { rank: "write", reason: `gh ${sub || "(unknown)"}`, template: "gh" };
+    }
+    return { rank: "write", reason: `shell.exec ${bin} \u2014 defaulted` };
+  }
+  if (step.kind === "http.call") {
+    const method = String(p.method ?? "GET");
+    const url = String(p.url ?? "");
+    if (/\/rest\/api\/\d+\/issue\/[^/]+$/.test(url) && method.toUpperCase() === "DELETE") {
+      return { rank: "destructive", reason: "Jira DELETE /issue/{id}", template: "jira" };
+    }
+    return { rank: httpRisk(method), reason: `HTTP ${method.toUpperCase()}` };
+  }
+  if (step.kind === "mcp.tool") {
+    const hint = String(p.riskHint ?? "");
+    if (hint === "read" || hint === "write" || hint === "destructive") {
+      return { rank: hint, reason: `mcp.tool riskHint=${hint}` };
+    }
+    return { rank: "write", reason: "mcp.tool defaulted to write" };
+  }
+  return { rank: "write", reason: `unknown kind ${String(step.kind)} \u2014 defaulted` };
+}
+function resolveEffectiveApproval(step, cls, opts) {
+  const requested = Boolean(step.autoApply);
+  if (cls.rank !== "destructive") {
+    return { autoApply: requested, forcedApproval: false };
+  }
+  const ack = Boolean(step.acknowledgeDestructive);
+  if (ack && opts.playbookSigned) {
+    return { autoApply: requested, forcedApproval: false };
+  }
+  return {
+    autoApply: false,
+    forcedApproval: true,
+    reason: ack ? "destructive + acknowledgeDestructive requires a signed playbook \u2014 forcing approval" : "destructive step \u2014 forcing approval (set acknowledgeDestructive on a signed playbook to auto-apply)"
+  };
+}
+
+// src/lib/pack.ts
+import fs3 from "fs/promises";
+import path4 from "path";
+import crypto3 from "crypto";
+function packBody(pack2) {
+  const { signature: _s, ...rest } = pack2;
+  void _s;
+  return canonicalize(rest);
+}
+function hashPack(pack2) {
+  return crypto3.createHash("sha256").update(packBody(pack2)).digest("hex");
+}
+async function loadPack(p) {
+  const raw = await fs3.readFile(path4.resolve(p), "utf8");
+  const parsed = JSON.parse(raw);
+  if (!parsed?.name || typeof parsed.name !== "string") throw new Error("pack.name required");
+  if (!parsed.version || typeof parsed.version !== "string")
+    throw new Error("pack.version required");
+  if (!Array.isArray(parsed.playbooks) || parsed.playbooks.length === 0) {
+    throw new Error("pack.playbooks must be a non-empty array");
+  }
+  return parsed;
+}
+var SAFE_NAME_RE = /[^a-zA-Z0-9._-]/g;
+function packInstallDir(pack2, rootDir) {
+  const safe2 = pack2.name.replace(SAFE_NAME_RE, "_");
+  return path4.join(rootDir, `${safe2}-${pack2.version}`);
+}
+async function installPack(source, rootDir) {
+  const pack2 = await loadPack(source);
+  const dir = packInstallDir(pack2, rootDir);
+  await fs3.mkdir(dir, { recursive: true });
+  const dest = path4.join(dir, "pack.json");
+  await fs3.writeFile(dest, JSON.stringify(pack2, null, 2) + "\n", "utf8");
+  return { pack: pack2, installed: dest };
+}
+async function listInstalledPacks(rootDir) {
+  const out = [];
+  try {
+    const entries = await fs3.readdir(rootDir, { withFileTypes: true });
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      const file = path4.join(rootDir, e.name, "pack.json");
+      try {
+        const raw = await fs3.readFile(file, "utf8");
+        out.push(JSON.parse(raw));
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return out;
+}
+
+// src/commands/simulate.ts
+import path5 from "path";
+async function runSimulate(opts) {
+  const workspace = path5.resolve(opts.workspace ?? process.cwd());
+  const pb = await loadPlaybook(opts.playbook);
+  const packAllow = await collectPackAllow(workspace);
+  const session = createSession({
+    workspace,
+    extraShellAllow: [...opts.extraShellAllow, ...packAllow.shell],
+    httpAllow: [...opts.httpAllow ?? [], ...packAllow.http],
+    mcpAllow: [...opts.mcpAllow ?? [], ...packAllow.mcp]
+  });
+  const sigCheck = pb.signature ? verifyPlaybookSignature(pb) : { ok: false, reason: "unsigned" };
+  const lint = lintPlaybook(pb);
+  const steps = [];
+  for (const step of pb.steps) {
+    steps.push(await simulateStep(session, pb, step));
+  }
+  const summary = {
+    total: steps.length,
+    wouldApply: steps.filter((s) => s.verdict === "would-apply").length,
+    needsApproval: steps.filter((s) => s.verdict === "needs-approval").length,
+    wouldFail: steps.filter((s) => s.verdict === "would-fail" || s.verdict === "unsupported").length,
+    destructive: steps.filter((s) => s.risk === "destructive").length
+  };
+  const report = {
+    playbook: opts.playbook,
+    signature: {
+      present: Boolean(pb.signature),
+      ok: pb.signature ? sigCheck.ok : void 0,
+      reason: pb.signature ? sigCheck.reason : void 0,
+      pubKey: pb.signature?.pubKey
+    },
+    lint,
+    steps,
+    summary
+  };
+  if (opts.json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    printHuman(report);
+  }
+  if (opts.strict && summary.wouldFail > 0) {
+    process.exitCode = 2;
+  }
+  return report;
+}
+async function simulateStep(session, pb, step) {
+  const autoApply = Boolean(step.autoApply);
+  const cls = classifyStep(step);
+  const approval = resolveEffectiveApproval(step, cls, {
+    playbookSigned: Boolean(pb.signature)
+  });
+  try {
+    const preview = await callRpc(session, step.kind, step.params);
+    const summary = summarizePreview(preview);
+    if (approval.forcedApproval || !approval.autoApply) {
+      return {
+        id: step.id,
+        label: step.label,
+        kind: step.kind,
+        autoApply,
+        risk: cls.rank,
+        riskReason: cls.reason,
+        verdict: "needs-approval",
+        reason: approval.reason ?? (autoApply ? "risk-gated" : "autoApply not set \u2014 human approval required in the PWA"),
+        previewSummary: summary
+      };
+    }
+    return {
+      id: step.id,
+      label: step.label,
+      kind: step.kind,
+      autoApply,
+      risk: cls.rank,
+      riskReason: cls.reason,
+      verdict: "would-apply",
+      previewSummary: summary
+    };
+  } catch (err) {
+    const msg = err.message;
+    return {
+      id: step.id,
+      label: step.label,
+      kind: step.kind,
+      autoApply,
+      risk: cls.rank,
+      riskReason: cls.reason,
+      verdict: "would-fail",
+      reason: msg
+    };
+  }
+}
+async function collectPackAllow(workspace) {
+  const packs = await listInstalledPacks(path5.join(workspace, ".aarmos/packs"));
+  const shell = /* @__PURE__ */ new Set();
+  const http = /* @__PURE__ */ new Set();
+  const mcp = /* @__PURE__ */ new Set();
+  for (const p of packs) {
+    for (const b of p.allow?.shell ?? []) shell.add(b);
+    for (const h of p.allow?.http ?? []) http.add(h);
+    for (const m of p.allow?.mcp ?? []) mcp.add(m);
+  }
+  return { shell: [...shell], http: [...http], mcp: [...mcp] };
+}
+function summarizePreview(preview) {
+  if (!preview || typeof preview !== "object") return String(preview);
+  const p = preview;
+  const body = p.action?.preview ?? p.preview ?? preview;
+  const s = JSON.stringify(body);
+  return s.length > 200 ? s.slice(0, 200) + "\u2026" : s;
+}
+async function callRpc(session, method, params) {
+  const res = await handleRpc(session, { id: 1, type: "rpc", method, params });
+  if ("type" in res && res.type === "error") throw new Error(res.error);
+  if ("type" in res && res.type === "result") return res.result;
+  throw new Error("unexpected rpc envelope");
+}
+function printHuman(r) {
+  const log6 = (s) => console.log(s);
+  log6("");
+  log6(`  aarmos simulate \u2014 ${r.playbook}`);
+  log6("");
+  if (r.signature.present) {
+    log6(
+      `  signature   : ${r.signature.ok ? "OK" : "INVALID"} (${r.signature.pubKey?.slice(0, 16)}\u2026)${r.signature.reason ? "  " + r.signature.reason : ""}`
+    );
+  } else {
+    log6("  signature   : (unsigned \u2014 allowed in dev; blocked under --enforce-signatures)");
+  }
+  if (r.lint.length > 0) {
+    log6("");
+    log6("  lint:");
+    for (const f of r.lint) {
+      log6(`    [${f.level}] ${f.stepId ? `${f.stepId}: ` : ""}${f.message}`);
+    }
+  }
+  log6("");
+  log6("  steps:");
+  for (const s of r.steps) {
+    const tag = s.verdict === "would-apply" ? "would-apply    " : s.verdict === "needs-approval" ? "needs-approval " : "would-fail     ";
+    log6(`    [${tag}] ${s.id}  ${s.label}  (risk: ${s.risk} \u2014 ${s.riskReason})`);
+    if (s.reason) log6(`        reason: ${s.reason}`);
+    if (s.previewSummary) log6(`        preview: ${s.previewSummary}`);
+  }
+  log6("");
+  log6(
+    `  summary     : ${r.summary.wouldApply} would-apply \xB7 ${r.summary.needsApproval} needs-approval \xB7 ${r.summary.wouldFail} would-fail \xB7 ${r.summary.destructive} destructive`
+  );
+  log6("");
+}
+
+// src/commands/run.ts
+async function startRun(opts) {
+  const workspace = path6.resolve(opts.workspace ?? process.cwd());
+  const playbook2 = await loadPlaybook(opts.playbook);
+  if (opts.enforceSignatures) {
+    if (!playbook2.signature) {
+      throw new Error(
+        "--enforce-signatures: playbook is unsigned. Run `aarmos playbook sign` first."
+      );
+    }
+    const v = verifyPlaybookSignature(playbook2);
+    if (!v.ok) throw new Error(`--enforce-signatures: ${v.reason}`);
+    if (opts.trustedPubKeys && opts.trustedPubKeys.length > 0) {
+      if (!opts.trustedPubKeys.includes(playbook2.signature.pubKey)) {
+        throw new Error(
+          `--enforce-signatures: signer ${playbook2.signature.pubKey} not in --trusted-pubkey set`
+        );
+      }
+    }
+  }
+  if (opts.dry) {
+    await runSimulate({
+      playbook: opts.playbook,
+      workspace: opts.workspace,
+      extraShellAllow: opts.extraShellAllow,
+      httpAllow: opts.httpAllow,
+      mcpAllow: opts.mcpAllow,
+      strict: true
+    });
+    return;
+  }
+  const packAllow = await collectPackAllow2(workspace);
+  const session = createSession({
+    workspace,
+    extraShellAllow: [...opts.extraShellAllow, ...packAllow.shell],
+    httpAllow: [...opts.httpAllow ?? [], ...packAllow.http],
+    mcpAllow: [...opts.mcpAllow ?? [], ...packAllow.mcp]
+  });
+  const receiptsPath = path6.resolve(opts.receipts);
+  await fs4.mkdir(path6.dirname(receiptsPath), { recursive: true });
+  log2("");
+  log2("  aarmos run (headless)");
+  log2(`    workspace   : ${workspace}`);
+  log2(`    playbook    : ${opts.playbook}  (${playbook2.name}, ${playbook2.steps.length} step[s])`);
+  log2(`    receipts    : ${receiptsPath}`);
+  log2(`    kill-switch : ${opts.killSwitch ?? "(none)"}`);
+  log2(`    ceiling     : ${opts.maxPerHour}/hour`);
+  log2(`    heartbeat   : ${opts.heartbeatUrl ?? "(none)"}`);
+  log2(`    mode        : ${opts.once ? "single pass" : "loop"}`);
+  log2("");
+  const nextRunAt = /* @__PURE__ */ new Map();
+  const now = Date.now();
+  for (const step of playbook2.steps) {
+    nextRunAt.set(step.id, now);
+  }
+  const applyTimestamps = [];
+  let stopped = false;
+  const stop = (why) => {
+    if (stopped) return;
+    stopped = true;
+    log2(`
+  [stop] ${why}`);
+  };
+  process.on("SIGINT", () => stop("SIGINT"));
+  process.on("SIGTERM", () => stop("SIGTERM"));
+  const heartbeatTimer = opts.heartbeatUrl ? setInterval(() => {
+    void postHeartbeat(opts, {
+      playbook: playbook2.name,
+      runsLastHour: applyTimestamps.length,
+      killed: killSwitchTripped(opts.killSwitch)
+    });
+  }, 3e4) : null;
+  try {
+    do {
+      if (killSwitchTripped(opts.killSwitch)) {
+        for (const step of playbook2.steps) {
+          const r = makeReceipt(playbook2, step, { mode: "skipped-killed" });
+          await appendReceipt(receiptsPath, r);
+          await postReceipt(opts, r);
+          const short = (r.hash ?? "").slice(0, 8) || "--------";
+          log2(`avar+ ${short} skipped-killed ${step.label}`);
         }
-        const alias = raw.slice(0, eq).trim();
-        const dsn = raw.slice(eq + 1).trim();
-        if (!alias || !dsn) {
-            throw new Error(`--allow-sql alias and dsn must be non-empty: ${raw}`);
+        stop(`kill-switch present at ${opts.killSwitch}`);
+        break;
+      }
+      const tickAt = Date.now();
+      pruneWindow(applyTimestamps, tickAt);
+      for (const step of playbook2.steps) {
+        if (stopped) break;
+        const due = (nextRunAt.get(step.id) ?? 0) <= tickAt;
+        if (!due) continue;
+        let receipt;
+        try {
+          const cls = classifyStep(step);
+          const approval = resolveEffectiveApproval(step, cls, {
+            playbookSigned: Boolean(playbook2.signature)
+          });
+          const preview = await callRpc2(session, step.kind, step.params);
+          const isPrev = isPreviewEnvelope(preview);
+          if (approval.forcedApproval || !approval.autoApply) {
+            receipt = makeReceipt(playbook2, step, {
+              mode: "needs-approval",
+              preview: isPrev ? preview.action.preview : preview,
+              risk: cls.rank,
+              riskReason: cls.reason,
+              approvalReason: approval.reason
+            });
+          } else if (applyTimestamps.length >= opts.maxPerHour) {
+            receipt = makeReceipt(playbook2, step, { mode: "skipped-ceiling", risk: cls.rank });
+          } else if (!isPrev) {
+            receipt = makeReceipt(playbook2, step, {
+              mode: "dry-run",
+              preview,
+              risk: cls.rank
+            });
+          } else {
+            const applyRes = await callRpc2(session, "apply.batch", {
+              actions: [{ kind: step.kind, params: step.params }]
+            });
+            const first = applyRes.results[0];
+            if (first?.ok) {
+              applyTimestamps.push(Date.now());
+              receipt = makeReceipt(playbook2, step, {
+                mode: "applied",
+                preview: preview.action.preview,
+                result: first.result,
+                risk: cls.rank
+              });
+            } else {
+              receipt = makeReceipt(playbook2, step, {
+                mode: "error",
+                preview: preview.action.preview,
+                error: first?.error ?? "apply.batch returned no result",
+                risk: cls.rank
+              });
+            }
+          }
+        } catch (err) {
+          receipt = makeReceipt(playbook2, step, {
+            mode: "error",
+            error: err.message
+          });
         }
-        if (!/^[a-zA-Z0-9._-]+$/.test(alias)) {
-            throw new Error(`--allow-sql alias must be [a-zA-Z0-9._-]+: ${alias}`);
+        await appendReceipt(receiptsPath, receipt);
+        await postReceipt(opts, receipt);
+        const short = (receipt.hash ?? "").slice(0, 8) || "--------";
+        log2(`avar+ ${short} ${receipt.mode} ${step.label}`);
+        if (!opts.once && step.intervalSec && step.intervalSec > 0) {
+          nextRunAt.set(step.id, Date.now() + step.intervalSec * 1e3);
         }
-        return { alias, dsn };
-    });
-    await startDev({
-        port: Number(opts.port),
-        pwaUrl: opts.pwa,
-        autoOpen: opts.open !== false,
-        extraShellAllow: opts.allowShell
-            ? String(opts.allowShell)
-                .split(",")
-                .map((s) => s.trim())
-                .filter(Boolean)
-            : [],
-        sqlAllow,
-        readAllow: opts.allowRead,
+      }
+      if (opts.once) break;
+      const soonest = Math.min(...playbook2.steps.map((s) => nextRunAt.get(s.id) ?? Infinity));
+      const waitMs = Math.max(1e3, Math.min(5e3, soonest - Date.now()));
+      await sleep(waitMs);
+    } while (!stopped);
+  } finally {
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+  }
+}
+function makeReceipt(pb, step, extra) {
+  const base = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    playbook: pb.name,
+    stepId: step.id,
+    label: step.label,
+    kind: step.kind,
+    mode: extra.mode,
+    preview: extra.preview,
+    result: extra.result,
+    error: extra.error,
+    risk: extra.risk,
+    riskReason: extra.riskReason,
+    approvalReason: extra.approvalReason
+  };
+  const hash = crypto4.createHash("sha256").update(JSON.stringify(base)).digest("hex");
+  return { ...base, hash };
+}
+async function appendReceipt(file, r) {
+  await fs4.appendFile(file, JSON.stringify(r) + "\n", "utf8");
+}
+async function collectPackAllow2(workspace) {
+  const packs = await listInstalledPacks(path6.join(workspace, ".aarmos/packs"));
+  const shell = /* @__PURE__ */ new Set();
+  const http = /* @__PURE__ */ new Set();
+  const mcp = /* @__PURE__ */ new Set();
+  for (const p of packs) {
+    for (const b of p.allow?.shell ?? []) shell.add(b);
+    for (const h of p.allow?.http ?? []) http.add(h);
+    for (const m of p.allow?.mcp ?? []) mcp.add(m);
+  }
+  return { shell: [...shell], http: [...http], mcp: [...mcp] };
+}
+function killSwitchTripped(file) {
+  if (!file) return false;
+  try {
+    fssync.accessSync(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pruneWindow(ts, now) {
+  const cutoff = now - 60 * 60 * 1e3;
+  while (ts.length > 0 && ts[0] < cutoff) ts.shift();
+}
+async function postReceipt(opts, r) {
+  if (!opts.heartbeatUrl) return;
+  await safePost(opts.heartbeatUrl.replace(/\/$/, "") + "/receipts", opts.heartbeatToken, r);
+}
+async function postHeartbeat(opts, body) {
+  await safePost(opts.heartbeatUrl.replace(/\/$/, "") + "/heartbeat", opts.heartbeatToken, {
+    ...body,
+    ts: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+async function safePost(url, token, body) {
+  try {
+    await fetch(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...token ? { authorization: `Bearer ${token}` } : {}
+      },
+      body: JSON.stringify(body)
     });
+  } catch {
+  }
+}
+function isPreviewEnvelope(x) {
+  return !!x && typeof x === "object" && x.preview === true;
+}
+async function callRpc2(session, method, params) {
+  const res = await handleRpc(session, { id: 1, type: "rpc", method, params });
+  if ("type" in res && res.type === "error") throw new Error(res.error);
+  if ("type" in res && res.type === "result") return res.result;
+  throw new Error("unexpected rpc envelope");
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function log2(s) {
+  console.log(s);
+}
+
+// src/commands/playbook.ts
+import fs5 from "fs/promises";
+import path7 from "path";
+var log3 = (s) => console.log(s);
+async function playbookKeygen(opts) {
+  const kp = await generateSigningKeyPair(path7.resolve(opts.out), opts.name);
+  log3("");
+  log3("  aarmos playbook keygen");
+  log3(`    private    : ${kp.privatePem}  (chmod 600 \u2014 do not commit)`);
+  log3(`    public key : ${kp.publicKey}`);
+  log3("");
+  log3("  Distribute the public key to reviewers; pin it via");
+  log3(`    aarmos run --enforce-signatures --trusted-pubkey ${kp.publicKey}`);
+  log3("");
+}
+async function playbookSign(opts) {
+  const pb = await loadPlaybook(opts.playbook);
+  const pem = await fs5.readFile(path7.resolve(opts.key), "utf8");
+  const signed = await signPlaybook(pb, pem);
+  const outPath = path7.resolve(opts.out ?? opts.playbook);
+  await writePlaybook(outPath, signed);
+  log3("");
+  log3(`  signed ${opts.playbook}`);
+  log3(`    pubkey : ${signed.signature.pubKey}`);
+  log3(`    out    : ${outPath}`);
+  log3("");
+}
+async function playbookVerify(opts) {
+  const pb = await loadPlaybook(opts.playbook);
+  const res = verifyPlaybookSignature(pb);
+  log3("");
+  log3(`  aarmos playbook verify \u2014 ${opts.playbook}`);
+  if (!pb.signature) {
+    log3("    unsigned");
+    process.exitCode = 1;
+    return;
+  }
+  log3(`    pubkey : ${pb.signature.pubKey}`);
+  log3(`    result : ${res.ok ? "OK" : "INVALID"}${res.reason ? "  " + res.reason : ""}`);
+  if (opts.trustedPubkey && pb.signature.pubKey !== opts.trustedPubkey) {
+    log3(`    trust  : REJECTED \u2014 signer not in trusted set`);
+    process.exitCode = 1;
+    return;
+  }
+  if (!res.ok) process.exitCode = 1;
+  log3("");
+}
+
+// src/commands/pack.ts
+import fs6 from "fs/promises";
+import path8 from "path";
+import crypto5 from "crypto";
+var log4 = (s) => console.log(s);
+var PACKS_DIR = ".aarmos/packs";
+async function packInstall(opts) {
+  const root = path8.resolve(opts.workspace ?? process.cwd(), PACKS_DIR);
+  const { pack: pack2, installed } = await installPack(opts.source, root);
+  log4("");
+  log4(`  installed ${pack2.name}@${pack2.version}`);
+  log4(`    hash    : ${hashPack(pack2)}`);
+  log4(`    signed  : ${pack2.signature ? pack2.signature.pubKey : "(no)"}`);
+  log4(`    at      : ${installed}`);
+  log4("");
+  log4("  Next: run one of the pack's playbooks");
+  for (const pb of pack2.playbooks) {
+    log4(
+      `    aarmos run --playbook ${path8.join(packInstallDir(pack2, PACKS_DIR), "playbook." + safe(pb.name) + ".json")}`
+    );
+  }
+  const dir = packInstallDir(pack2, root);
+  for (const pb of pack2.playbooks) {
+    const pbFile = path8.join(dir, `playbook.${safe(pb.name)}.json`);
+    await fs6.writeFile(pbFile, JSON.stringify(pb, null, 2) + "\n", "utf8");
+  }
+  log4("");
+}
+async function packList(opts) {
+  const root = path8.resolve(opts.workspace ?? process.cwd(), PACKS_DIR);
+  const packs = await listInstalledPacks(root);
+  log4("");
+  log4(`  installed packs (${root})`);
+  if (packs.length === 0) log4("    (none)");
+  for (const p of packs) {
+    log4(
+      `    ${p.name}@${p.version}  hash=${hashPack(p).slice(0, 16)}\u2026  signed=${p.signature ? "yes" : "no"}  playbooks=${p.playbooks.length}`
+    );
+  }
+  log4("");
+}
+async function packVerify(opts) {
+  const pack2 = await loadPack(opts.source);
+  log4("");
+  log4(`  aarmos pack verify \u2014 ${pack2.name}@${pack2.version}`);
+  log4(`    hash    : ${hashPack(pack2)}`);
+  if (!pack2.signature) {
+    log4("    signed  : NO");
+    process.exitCode = 1;
+    return;
+  }
+  const ok = verifyPackSignatureDirect(pack2);
+  log4(`    signer  : ${pack2.signature.pubKey}`);
+  log4(`    result  : ${ok ? "OK" : "INVALID"}`);
+  if (opts.trustedPubkey && pack2.signature.pubKey !== opts.trustedPubkey) {
+    log4("    trust   : REJECTED \u2014 signer not in trusted set");
+    process.exitCode = 1;
+  } else if (!ok) {
+    process.exitCode = 1;
+  }
+  for (const pb of pack2.playbooks) {
+    if (pb.signature) {
+      const v = verifyPlaybookSignature(pb);
+      log4(
+        `    playbook signature (${pb.name}): ${v.ok ? "OK" : "INVALID"}${v.reason ? " " + v.reason : ""}`
+      );
+    }
+  }
+  log4("");
+}
+function verifyPackSignatureDirect(pack2) {
+  if (!pack2.signature) return false;
+  const body = Buffer.from(packBody(pack2));
+  try {
+    const spkiPrefix = Buffer.from([
+      48,
+      42,
+      48,
+      5,
+      6,
+      3,
+      43,
+      101,
+      112,
+      3,
+      33,
+      0
+    ]);
+    const b64uDecode2 = (s) => Buffer.from(
+      s.replace(/-/g, "+").replace(/_/g, "/") + "===".slice((s.length + 3) % 4),
+      "base64"
+    );
+    const rawPub = b64uDecode2(pack2.signature.pubKey);
+    if (rawPub.length !== 32) return false;
+    const der = Buffer.concat([spkiPrefix, rawPub]);
+    const key = crypto5.createPublicKey({ key: der, format: "der", type: "spki" });
+    return crypto5.verify(null, body, key, b64uDecode2(pack2.signature.sig));
+  } catch {
+    return false;
+  }
+}
+function safe(s) {
+  return s.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+
+// src/commands/attest.ts
+import fs8 from "fs/promises";
+import path10 from "path";
+
+// src/lib/attest.ts
+import fs7 from "fs/promises";
+import path9 from "path";
+import crypto6 from "crypto";
+async function buildAttestation(opts) {
+  const until = opts.until ?? /* @__PURE__ */ new Date();
+  const since = opts.since ?? /* @__PURE__ */ new Date(0);
+  const receipts = [];
+  try {
+    const raw = await fs7.readFile(opts.receiptsFile, "utf8");
+    for (const line of raw.split("\n")) {
+      const t = line.trim();
+      if (!t) continue;
+      let obj;
+      try {
+        obj = JSON.parse(t);
+      } catch {
+        continue;
+      }
+      const at = Date.parse(obj.ts);
+      if (Number.isFinite(at) && at >= since.getTime() && at <= until.getTime()) {
+        receipts.push(obj);
+      }
+    }
+  } catch {
+  }
+  const rootHash = merkleRoot(receipts.map((r) => r.hash ?? ""));
+  let playbookEntry;
+  if (opts.playbookFile) {
+    const pb = await loadPlaybook(opts.playbookFile);
+    playbookEntry = {
+      name: pb.name,
+      hash: hashPlaybook(pb),
+      signed: Boolean(pb.signature),
+      pubKey: pb.signature?.pubKey
+    };
+  }
+  let policyHash;
+  if (opts.policyFile) {
+    try {
+      const raw = await fs7.readFile(opts.policyFile, "utf8");
+      policyHash = crypto6.createHash("sha256").update(raw).digest("hex");
+    } catch {
+    }
+  }
+  const packs = opts.packsDir ? (await listInstalledPacks(opts.packsDir)).map((p) => ({
+    name: p.name,
+    version: p.version,
+    hash: hashPack(p)
+  })) : [];
+  return {
+    version: 1,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    since: since.toISOString(),
+    until: until.toISOString(),
+    playbook: playbookEntry,
+    policyHash,
+    packs,
+    receipts,
+    rootHash
+  };
+}
+function attestationBody(a) {
+  const { signature: _s, ...rest } = a;
+  void _s;
+  return canonicalize(rest);
+}
+async function signAttestation(a, privateKeyPem) {
+  const key = crypto6.createPrivateKey(privateKeyPem);
+  const sig = crypto6.sign(null, Buffer.from(attestationBody(a)), key);
+  const pubDer = crypto6.createPublicKey(key).export({ format: "der", type: "spki" });
+  const rawPub = pubDer.subarray(pubDer.length - 32);
+  const b64u2 = (b) => b.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return { ...a, signature: { alg: "ed25519", pubKey: b64u2(rawPub), sig: b64u2(sig) } };
+}
+function verifyAttestation(a) {
+  const recomputed = merkleRoot(a.receipts.map((r) => r.hash ?? ""));
+  if (recomputed !== a.rootHash) {
+    return { ok: false, reason: `rootHash mismatch (bundle=${a.rootHash} computed=${recomputed})` };
+  }
+  if (!a.signature) return { ok: true };
+  if (a.signature.alg !== "ed25519") {
+    return { ok: false, reason: `unsupported alg: ${a.signature.alg}` };
+  }
+  try {
+    const spkiPrefix = Buffer.from([
+      48,
+      42,
+      48,
+      5,
+      6,
+      3,
+      43,
+      101,
+      112,
+      3,
+      33,
+      0
+    ]);
+    const b64uDecode2 = (s) => Buffer.from(
+      s.replace(/-/g, "+").replace(/_/g, "/") + "===".slice((s.length + 3) % 4),
+      "base64"
+    );
+    const rawPub = b64uDecode2(a.signature.pubKey);
+    if (rawPub.length !== 32) return { ok: false, reason: "pubKey must be 32 bytes" };
+    const der = Buffer.concat([spkiPrefix, rawPub]);
+    const key = crypto6.createPublicKey({ key: der, format: "der", type: "spki" });
+    const ok = crypto6.verify(
+      null,
+      Buffer.from(attestationBody(a)),
+      key,
+      b64uDecode2(a.signature.sig)
+    );
+    return ok ? { ok: true } : { ok: false, reason: "signature does not match bundle body" };
+  } catch (err) {
+    return { ok: false, reason: err.message };
+  }
+}
+function merkleRoot(hashes) {
+  let acc = crypto6.createHash("sha256").update("").digest("hex");
+  for (const h of hashes) {
+    acc = crypto6.createHash("sha256").update(acc + h).digest("hex");
+  }
+  return acc;
+}
+function parseSince(s) {
+  const m = /^(\d+)\s*([hdm])$/.exec(s.trim());
+  if (m) {
+    const n = Number(m[1]);
+    const unit = m[2];
+    const ms = unit === "h" ? n * 36e5 : unit === "d" ? n * 864e5 : n * 6e4;
+    return new Date(Date.now() - ms);
+  }
+  const t = Date.parse(s);
+  if (Number.isFinite(t)) return new Date(t);
+  throw new Error(`--since: expected e.g. 24h, 7d, 30m, or an ISO date (got: ${s})`);
+}
+async function writeAttestation(file, a) {
+  await fs7.mkdir(path9.dirname(path9.resolve(file)), { recursive: true });
+  await fs7.writeFile(path9.resolve(file), JSON.stringify(a, null, 2) + "\n", "utf8");
+}
+async function readAttestation(file) {
+  const raw = await fs7.readFile(path9.resolve(file), "utf8");
+  return JSON.parse(raw);
+}
+
+// src/commands/attest.ts
+var log5 = (s) => console.log(s);
+async function runAttest(opts) {
+  const workspace = path10.resolve(opts.workspace ?? process.cwd());
+  const since = opts.since ? parseSince(opts.since) : /* @__PURE__ */ new Date(0);
+  const bundle = await buildAttestation({
+    workspace,
+    receiptsFile: path10.resolve(opts.receipts),
+    since,
+    until: /* @__PURE__ */ new Date(),
+    playbookFile: opts.playbook,
+    policyFile: opts.policy ?? path10.join(workspace, "aarmos.json"),
+    packsDir: path10.join(workspace, ".aarmos/packs")
+  });
+  const finalBundle = opts.signKey ? await signAttestation(bundle, await fs8.readFile(path10.resolve(opts.signKey), "utf8")) : bundle;
+  await writeAttestation(opts.out, finalBundle);
+  log5("");
+  log5("  aarmos attest");
+  log5(`    window     : ${finalBundle.since}  \u2192  ${finalBundle.until}`);
+  log5(`    receipts   : ${finalBundle.receipts.length}`);
+  log5(
+    `    playbook   : ${finalBundle.playbook ? finalBundle.playbook.name + " (" + finalBundle.playbook.hash.slice(0, 16) + "\u2026)" : "(none)"}`
+  );
+  log5(
+    `    policy     : ${finalBundle.policyHash ? finalBundle.policyHash.slice(0, 16) + "\u2026" : "(none)"}`
+  );
+  log5(`    packs      : ${finalBundle.packs.length}`);
+  log5(`    rootHash   : ${finalBundle.rootHash}`);
+  log5(`    signature  : ${finalBundle.signature ? finalBundle.signature.pubKey : "(unsigned)"}`);
+  log5(`    written to : ${path10.resolve(opts.out)}`);
+  log5("");
+}
+async function runAttestVerify(opts) {
+  const bundle = await readAttestation(opts.file);
+  const res = verifyAttestation(bundle);
+  log5("");
+  log5(`  aarmos attest verify \u2014 ${opts.file}`);
+  log5(`    receipts  : ${bundle.receipts.length}`);
+  log5(`    rootHash  : ${bundle.rootHash}`);
+  log5(`    result    : ${res.ok ? "OK" : "INVALID"}${res.reason ? "  " + res.reason : ""}`);
+  if (bundle.signature) {
+    log5(`    signer    : ${bundle.signature.pubKey}`);
+    if (opts.trustedPubkey && bundle.signature.pubKey !== opts.trustedPubkey) {
+      log5("    trust     : REJECTED \u2014 signer not in trusted set");
+      process.exitCode = 1;
+    }
+  } else {
+    log5("    signer    : (unsigned)");
+  }
+  if (!res.ok) process.exitCode = 1;
+  log5("");
+}
+
+// src/index.ts
+var program = new Command();
+program.name("aarmos").description("Aarmos CLI bridge \u2014 native host for the Aarmos PWA").version("0.0.0-dev");
+function collect(value, prev) {
+  return [...prev, value];
+}
+program.command("dev").description("Start the local bridge and pair with the PWA").option("-p, --port <port>", "WebSocket port to bind on 127.0.0.1", "7423").option(
+  "--pwa <url>",
+  "PWA base URL to open for pairing",
+  process.env.AARMOS_PWA_URL ?? "https://www.aarmos.io"
+).option("--no-open", "Do not auto-open the PWA in the browser").option(
+  "--allow-shell <bins>",
+  "Comma-separated additional shell binaries to allow (in addition to defaults)",
+  ""
+).option(
+  "--allow-sql <alias=dsn>",
+  "Register a read-only Postgres target. Repeatable. Example: --allow-sql prod=postgres://readonly@\u2026/db",
+  collect,
+  []
+).option(
+  "--allow-read <path>",
+  "Allow fs.scopedRead / fs.scopedList inside this absolute path (outside the workspace). Repeatable.",
+  collect,
+  []
+).action(async (opts) => {
+  const sqlAllow = opts.allowSql.map((raw) => {
+    const eq = raw.indexOf("=");
+    if (eq < 0) {
+      throw new Error(`--allow-sql expects <alias>=<dsn>, got: ${raw}`);
+    }
+    const alias = raw.slice(0, eq).trim();
+    const dsn = raw.slice(eq + 1).trim();
+    if (!alias || !dsn) {
+      throw new Error(`--allow-sql alias and dsn must be non-empty: ${raw}`);
+    }
+    if (!/^[a-zA-Z0-9._-]+$/.test(alias)) {
+      throw new Error(`--allow-sql alias must be [a-zA-Z0-9._-]+: ${alias}`);
+    }
+    return { alias, dsn };
+  });
+  await startDev({
+    port: Number(opts.port),
+    pwaUrl: opts.pwa,
+    autoOpen: opts.open !== false,
+    extraShellAllow: opts.allowShell ? String(opts.allowShell).split(",").map((s) => s.trim()).filter(Boolean) : [],
+    sqlAllow,
+    readAllow: opts.allowRead
+  });
 });
-program
-    .command("demo")
-    .description("Scripted end-to-end walkthrough of the dry-run pipeline (no PWA required)")
-    .option("--apply", "Commit the proposed batch after previewing (default: preview only)", false)
-    .option("--workspace <path>", "Workspace to run against (default: cwd)")
-    .action(async (opts) => {
-    await runDemo({ apply: Boolean(opts.apply), workspace: opts.workspace });
+program.command("demo").description("Scripted end-to-end walkthrough of the dry-run pipeline (no PWA required)").option("--apply", "Commit the proposed batch after previewing (default: preview only)", false).option("--workspace <path>", "Workspace to run against (default: cwd)").action(async (opts) => {
+  await runDemo({ apply: Boolean(opts.apply), workspace: opts.workspace });
 });
-program
-    .command("run")
-    .description("Headless unattended loop — executes a playbook against the local dry-run pipeline")
-    .requiredOption("--playbook <path>", "Path to a JSON playbook file")
-    .option("--once", "Run one pass and exit (default: loop)", false)
-    .option("--dry", "Simulate only — no side effects. Prints per-step verdicts and exits.", false)
-    .option("--enforce-signatures", "Refuse to run unless the playbook is signed (Ed25519)", false)
-    .option("--trusted-pubkey <key>", "Only accept playbooks signed by this pubkey. Repeatable. Requires --enforce-signatures.", collect, [])
-    .option("--kill-switch <file>", "Halt gracefully when this file exists")
-    .option("--receipts <file>", "Append signed receipts here (JSONL)", ".aarmos/receipts.jsonl")
-    .option("--max-per-hour <n>", "Ceiling on applied actions per rolling hour", "60")
-    .option("--heartbeat-url <url>", "POST receipts + heartbeats to this base URL")
-    .option("--heartbeat-token <token>", "Bearer token attached to heartbeat POSTs")
-    .option("--workspace <path>", "Workspace to run against (default: cwd)")
-    .option("--allow-shell <bins>", "Comma-separated additional shell binaries to allow (in addition to defaults)", "")
-    .option("--allow-http <host>", "Allow governed http.call steps to reach this host. Repeatable.", collect, [])
-    .option("--allow-mcp <url>", "Allow governed mcp.tool steps to invoke this MCP endpoint. Repeatable.", collect, [])
-    .action(async (opts) => {
-    await startRun({
-        playbook: opts.playbook,
-        once: Boolean(opts.once),
-        dry: Boolean(opts.dry),
-        enforceSignatures: Boolean(opts.enforceSignatures),
-        trustedPubKeys: opts.trustedPubkey,
-        killSwitch: opts.killSwitch,
-        receipts: opts.receipts,
-        maxPerHour: Number(opts.maxPerHour),
-        heartbeatUrl: opts.heartbeatUrl,
-        heartbeatToken: opts.heartbeatToken,
-        workspace: opts.workspace,
-        extraShellAllow: opts.allowShell
-            ? String(opts.allowShell)
-                .split(",")
-                .map((s) => s.trim())
-                .filter(Boolean)
-            : [],
-        httpAllow: opts.allowHttp,
-        mcpAllow: opts.allowMcp,
-    });
+program.command("run").description("Headless unattended loop \u2014 executes a playbook against the local dry-run pipeline").requiredOption("--playbook <path>", "Path to a JSON playbook file").option("--once", "Run one pass and exit (default: loop)", false).option("--dry", "Simulate only \u2014 no side effects. Prints per-step verdicts and exits.", false).option("--enforce-signatures", "Refuse to run unless the playbook is signed (Ed25519)", false).option(
+  "--trusted-pubkey <key>",
+  "Only accept playbooks signed by this pubkey. Repeatable. Requires --enforce-signatures.",
+  collect,
+  []
+).option("--kill-switch <file>", "Halt gracefully when this file exists").option("--receipts <file>", "Append signed receipts here (JSONL)", ".aarmos/receipts.jsonl").option("--max-per-hour <n>", "Ceiling on applied actions per rolling hour", "60").option("--heartbeat-url <url>", "POST receipts + heartbeats to this base URL").option("--heartbeat-token <token>", "Bearer token attached to heartbeat POSTs").option("--workspace <path>", "Workspace to run against (default: cwd)").option(
+  "--allow-shell <bins>",
+  "Comma-separated additional shell binaries to allow (in addition to defaults)",
+  ""
+).option(
+  "--allow-http <host>",
+  "Allow governed http.call steps to reach this host. Repeatable.",
+  collect,
+  []
+).option(
+  "--allow-mcp <url>",
+  "Allow governed mcp.tool steps to invoke this MCP endpoint. Repeatable.",
+  collect,
+  []
+).action(async (opts) => {
+  await startRun({
+    playbook: opts.playbook,
+    once: Boolean(opts.once),
+    dry: Boolean(opts.dry),
+    enforceSignatures: Boolean(opts.enforceSignatures),
+    trustedPubKeys: opts.trustedPubkey,
+    killSwitch: opts.killSwitch,
+    receipts: opts.receipts,
+    maxPerHour: Number(opts.maxPerHour),
+    heartbeatUrl: opts.heartbeatUrl,
+    heartbeatToken: opts.heartbeatToken,
+    workspace: opts.workspace,
+    extraShellAllow: opts.allowShell ? String(opts.allowShell).split(",").map((s) => s.trim()).filter(Boolean) : [],
+    httpAllow: opts.allowHttp,
+    mcpAllow: opts.allowMcp
+  });
 });
-program
-    .command("simulate")
-    .description("Compile-time governance: replay a playbook through the dry-run pipeline without applying anything")
-    .requiredOption("--playbook <path>", "Path to a JSON playbook file")
-    .option("--workspace <path>", "Workspace to simulate against (default: cwd)")
-    .option("--json", "Emit machine-readable JSON (for CI)", false)
-    .option("--strict", "Exit non-zero if any step would fail", false)
-    .option("--allow-shell <bins>", "Comma-separated additional shell binaries to allow", "")
-    .option("--allow-http <host>", "Allow http.call to this host. Repeatable.", collect, [])
-    .option("--allow-mcp <url>", "Allow mcp.tool against this MCP endpoint. Repeatable.", collect, [])
-    .action(async (opts) => {
-    await runSimulate({
-        playbook: opts.playbook,
-        workspace: opts.workspace,
-        json: Boolean(opts.json()),
-        strict: Boolean(opts.strict),
-        extraShellAllow: opts.allowShell
-            ? String(opts.allowShell)
-                .split(",")
-                .map((s) => s.trim())
-                .filter(Boolean)
-            : [],
-        httpAllow: opts.allowHttp,
-        mcpAllow: opts.allowMcp,
-    });
+program.command("simulate").description(
+  "Compile-time governance: replay a playbook through the dry-run pipeline without applying anything"
+).requiredOption("--playbook <path>", "Path to a JSON playbook file").option("--workspace <path>", "Workspace to simulate against (default: cwd)").option("--json", "Emit machine-readable JSON (for CI)", false).option("--strict", "Exit non-zero if any step would fail", false).option("--allow-shell <bins>", "Comma-separated additional shell binaries to allow", "").option(
+  "--allow-http <host>",
+  "Allow http.call to this host. Repeatable.",
+  collect,
+  []
+).option(
+  "--allow-mcp <url>",
+  "Allow mcp.tool against this MCP endpoint. Repeatable.",
+  collect,
+  []
+).action(async (opts) => {
+  await runSimulate({
+    playbook: opts.playbook,
+    workspace: opts.workspace,
+    json: Boolean(opts.json()),
+    strict: Boolean(opts.strict),
+    extraShellAllow: opts.allowShell ? String(opts.allowShell).split(",").map((s) => s.trim()).filter(Boolean) : [],
+    httpAllow: opts.allowHttp,
+    mcpAllow: opts.allowMcp
+  });
 });
-const playbook = program
-    .command("playbook")
-    .description("Sign, verify, and manage Ed25519 keys for playbooks (optional; only enforced under --enforce-signatures)");
-playbook
-    .command("keygen")
-    .description("Generate an Ed25519 signing keypair")
-    .option("--out <dir>", "Directory to write keys into", ".aarmos/keys")
-    .option("--name <name>", "Basename for the key files", "playbook")
-    .action(async (opts) => {
-    await playbookKeygen({ out: opts.out, name: opts.name });
+var playbook = program.command("playbook").description(
+  "Sign, verify, and manage Ed25519 keys for playbooks (optional; only enforced under --enforce-signatures)"
+);
+playbook.command("keygen").description("Generate an Ed25519 signing keypair").option("--out <dir>", "Directory to write keys into", ".aarmos/keys").option("--name <name>", "Basename for the key files", "playbook").action(async (opts) => {
+  await playbookKeygen({ out: opts.out, name: opts.name });
 });
-playbook
-    .command("sign")
-    .description("Sign a playbook in place (or to --out)")
-    .requiredOption("--playbook <path>", "Playbook to sign")
-    .requiredOption("--key <pem>", "Ed25519 private key PEM file")
-    .option("--out <path>", "Write signed playbook here (default: overwrite in place)")
-    .action(async (opts) => {
-    await playbookSign({ playbook: opts.playbook, key: opts.key, out: opts.out });
+playbook.command("sign").description("Sign a playbook in place (or to --out)").requiredOption("--playbook <path>", "Playbook to sign").requiredOption("--key <pem>", "Ed25519 private key PEM file").option("--out <path>", "Write signed playbook here (default: overwrite in place)").action(async (opts) => {
+  await playbookSign({ playbook: opts.playbook, key: opts.key, out: opts.out });
 });
-playbook
-    .command("verify")
-    .description("Verify a signed playbook")
-    .requiredOption("--playbook <path>", "Playbook to verify")
-    .option("--trusted-pubkey <key>", "Reject if signer is not this pubkey")
-    .action(async (opts) => {
-    await playbookVerify({ playbook: opts.playbook, trustedPubkey: opts.trustedPubkey });
+playbook.command("verify").description("Verify a signed playbook").requiredOption("--playbook <path>", "Playbook to verify").option("--trusted-pubkey <key>", "Reject if signer is not this pubkey").action(async (opts) => {
+  await playbookVerify({ playbook: opts.playbook, trustedPubkey: opts.trustedPubkey });
 });
-const pack = program
-    .command("pack")
-    .description("Install / list / verify certified playbook packs (signed bundles of playbooks + scope allowlists)");
-pack
-    .command("install")
-    .description("Install a pack from a local path (or URL — future).")
-    .requiredOption("--source <path>", "Path to a pack JSON file")
-    .option("--workspace <path>", "Workspace to install into (default: cwd)")
-    .action(async (opts) => {
-    await packInstall({ source: opts.source, workspace: opts.workspace });
+var pack = program.command("pack").description(
+  "Install / list / verify certified playbook packs (signed bundles of playbooks + scope allowlists)"
+);
+pack.command("install").description("Install a pack from a local path (or URL \u2014 future).").requiredOption("--source <path>", "Path to a pack JSON file").option("--workspace <path>", "Workspace to install into (default: cwd)").action(async (opts) => {
+  await packInstall({ source: opts.source, workspace: opts.workspace });
 });
-pack
-    .command("list")
-    .description("List installed packs")
-    .option("--workspace <path>", "Workspace to inspect (default: cwd)")
-    .action(async (opts) => {
-    await packList({ workspace: opts.workspace });
+pack.command("list").description("List installed packs").option("--workspace <path>", "Workspace to inspect (default: cwd)").action(async (opts) => {
+  await packList({ workspace: opts.workspace });
 });
-pack
-    .command("verify")
-    .description("Verify a pack's Ed25519 signature")
-    .requiredOption("--source <path>", "Path to a pack JSON file")
-    .option("--trusted-pubkey <key>", "Reject if signer is not this pubkey")
-    .action(async (opts) => {
-    await packVerify({ source: opts.source, trustedPubkey: opts.trustedPubkey });
+pack.command("verify").description("Verify a pack's Ed25519 signature").requiredOption("--source <path>", "Path to a pack JSON file").option("--trusted-pubkey <key>", "Reject if signer is not this pubkey").action(async (opts) => {
+  await packVerify({ source: opts.source, trustedPubkey: opts.trustedPubkey });
 });
-const attest = program
-    .command("attest")
-    .description("Export a signed audit bundle (receipts + policy hash + pack hashes + rootHash) — verifiable offline")
-    .option("--since <window>", "Only include receipts from this window (e.g. 24h, 7d, or ISO date)", "24h")
-    .option("--out <file>", "Where to write the attestation JSON", "audit.attest.json")
-    .option("--workspace <path>", "Workspace to attest against (default: cwd)")
-    .option("--receipts <file>", "Receipts JSONL to fold in", ".aarmos/receipts.jsonl")
-    .option("--playbook <path>", "Include this playbook's hash + signature")
-    .option("--policy <path>", "Path to aarmos.json (default: <workspace>/aarmos.json())")
-    .option("--sign-key <pem>", "Ed25519 private key PEM — signs the bundle so auditors can verify offline")
-    .action(async (opts) => {
-    await runAttest({
-        out: opts.out,
-        since: opts.since,
-        workspace: opts.workspace,
-        receipts: opts.receipts,
-        playbook: opts.playbook,
-        policy: opts.policy,
-        signKey: opts.signKey,
-    });
+var attest = program.command("attest").description(
+  "Export a signed audit bundle (receipts + policy hash + pack hashes + rootHash) \u2014 verifiable offline"
+).option(
+  "--since <window>",
+  "Only include receipts from this window (e.g. 24h, 7d, or ISO date)",
+  "24h"
+).option("--out <file>", "Where to write the attestation JSON", "audit.attest.json").option("--workspace <path>", "Workspace to attest against (default: cwd)").option("--receipts <file>", "Receipts JSONL to fold in", ".aarmos/receipts.jsonl").option("--playbook <path>", "Include this playbook's hash + signature").option("--policy <path>", "Path to aarmos.json (default: <workspace>/aarmos.json())").option(
+  "--sign-key <pem>",
+  "Ed25519 private key PEM \u2014 signs the bundle so auditors can verify offline"
+).action(async (opts) => {
+  await runAttest({
+    out: opts.out,
+    since: opts.since,
+    workspace: opts.workspace,
+    receipts: opts.receipts,
+    playbook: opts.playbook,
+    policy: opts.policy,
+    signKey: opts.signKey
+  });
 });
-attest
-    .command("verify")
-    .description("Verify an attestation bundle offline — recomputes rootHash and checks signature")
-    .requiredOption("--file <path>", "Attestation JSON to verify")
-    .option("--trusted-pubkey <key>", "Reject if signer is not this pubkey")
-    .action(async (opts) => {
-    await runAttestVerify({ file: opts.file, trustedPubkey: opts.trustedPubkey });
+attest.command("verify").description("Verify an attestation bundle offline \u2014 recomputes rootHash and checks signature").requiredOption("--file <path>", "Attestation JSON to verify").option("--trusted-pubkey <key>", "Reject if signer is not this pubkey").action(async (opts) => {
+  await runAttestVerify({ file: opts.file, trustedPubkey: opts.trustedPubkey });
 });
-// aarmos verify — offline AVAR bundle verifier (AVAR spec §6).
-// Uses the same @aarmos/avar-core module the browser drop-zone at
-// /trust/verify uses, so results are bit-identical across runtimes.
-program
-    .command("verify")
-    .description("Verify an AVAR bundle offline (.avar.zip)")
-    .argument("<bundle>", "Path to a .avar.zip bundle")
-    .option("--json", "Emit the VerificationReport as JSON on stdout")
-    .option("--quiet", "Suppress all human-readable output")
-    .option("--strict", "Exit non-zero on 'valid-with-warnings'")
-    .action(async (bundle, opts) => {
-    const { runVerify } = await import("./commands/verify.js");
-    const code = await runVerify({
-        file: bundle,
-        json: !!opts.json(),
-        quiet: !!opts.quiet,
-        strict: !!opts.strict,
-    });
-    process.exit(code);
+program.command("verify").description("Verify an AVAR bundle offline (.avar.zip)").argument("<bundle>", "Path to a .avar.zip bundle").option("--json", "Emit the VerificationReport as JSON on stdout").option("--quiet", "Suppress all human-readable output").option("--strict", "Exit non-zero on 'valid-with-warnings'").action(async (bundle, opts) => {
+  const { runVerify } = await import("./verify-O6X7MFEE.js");
+  const code = await runVerify({
+    file: bundle,
+    json: !!opts.json(),
+    quiet: !!opts.quiet,
+    strict: !!opts.strict
+  });
+  process.exit(code);
 });
 program.parseAsync(process.argv).catch((err) => {
-    console.error("[aarmos] fatal:", err);
-    process.exit(1);
+  console.error("[aarmos] fatal:", err);
+  process.exit(1);
 });
-//# sourceMappingURL=index.js.map