@dzhechkov/harness-cli 0.3.227 → 0.3.229

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/harness-cli",
-  "version": "0.3.227",
+  "version": "0.3.229",
   "description": "The dz CLI — install AI skills for Claude Code, Codex, OpenCode, Hermes, OpenClaude, GitHub Copilot. 35 commands, 13 presets, 6 platform targets.",
   "type": "module",
   "license": "MIT",
@@ -55,7 +55,7 @@
     "@dzhechkov/skills-reverse-engineering": "^0.1.0",
     "@dzhechkov/skills-presentation-storyteller": "^0.1.0",
     "@dzhechkov/skills-website-cloner": "^0.1.0",
-    "@dzhechkov/harness-core": "0.3.120"
+    "@dzhechkov/harness-core": "0.3.122"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",

package/src/cli.ts

@@ -4,7 +4,7 @@
  * @packageDocumentation
  */
 
-import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, readlinkSync, renameSync, rmdirSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmdirSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execSync } from 'node:child_process';
@@ -101,6 +101,12 @@ import {
   buildSbom,
   resolveTrustRoot,
   decideVerifyPolicy,
+  generateSigningKeypair,
+  evaluateGuard,
+  resolveRules,
+  auditRecord,
+  guardExitCode,
+  DEFAULT_RULES,
   decideProvenance,
   isInsideTree,
   signManifest,
@@ -3230,10 +3236,73 @@ function reportPackVerification(
 }
 
 function cmdSign(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
+  // `dz sign --init` — one-time keygen. Writes the PRIVATE key OUTSIDE the repo (default ~/.dz/keys/dz.key,
+  // mode 0600) and prints the PUBLIC key for the operator to commit as keys/dz.pub. The private key never
+  // touches the repo or a tarball (the hard invariant — enforced by assertKeyOutsideTree).
+  if (flags.has('init')) {
+    const outPath = resolve(cwd, options.get('out') ?? join(homedir(), '.dz', 'keys', 'dz.key'));
+    // Resolve symlinks BEFORE the containment check: an --out (or a parent dir) that is a symlink pointing
+    // INTO the repo would otherwise slip the private key inside the tree past a string-only guard — including a
+    // DANGLING symlink whose target does not exist yet (existsSync follows the link and reports false, so the
+    // symlink itself must be resolved via lstat/readlink, not existsSync).
+    const realTarget = ((): string => {
+      // walk up to the deepest path that exists as ANY entry (file, dir, or even a dangling symlink).
+      let anc = outPath;
+      const tail: string[] = [];
+      for (;;) {
+        try { lstatSync(anc); break; } catch { /* not present */ }
+        const parent = dirname(anc);
+        if (parent === anc) return outPath; // reached root without an existing entry
+        tail.unshift(basename(anc));
+        anc = parent;
+      }
+      let base: string;
+      try {
+        base = realpathSync(anc); // resolves dirs/files and any RESOLVABLE symlink chain
+      } catch {
+        // `anc` exists but realpath threw → a dangling symlink: resolve its immediate target by hand.
+        try { base = resolve(dirname(anc), readlinkSync(anc)); } catch { return outPath; }
+      }
+      return tail.length ? join(base, ...tail) : base;
+    })();
+    try {
+      assertKeyOutsideTree(realTarget, cwd);
+    } catch (err) {
+      write(`dz sign --init: ${(err as Error).message}`);
+      write('  choose an --out path (and parent) OUTSIDE the repository (e.g. ~/.dz/keys/dz.key)');
+      return 1;
+    }
+    if (existsSync(outPath) && !flags.has('force')) {
+      write(`dz sign --init: ${outPath} already exists — refusing to overwrite (pass --force to replace)`);
+      write('  overwriting a signing key orphans every pack signed with the old one.');
+      return 1;
+    }
+    const { privateKey, publicKey } = generateSigningKeypair();
+    try {
+      mkdirSync(dirname(outPath), { recursive: true });
+      // Unlink an existing file first: writeFileSync's `mode` is ignored when the file already exists, so a
+      // pre-existing 0644 key would stay world-readable after --force. Removing it forces a fresh 0600 create.
+      if (existsSync(outPath)) rmSync(outPath, { force: true });
+      writeFileSync(outPath, privateKey, { mode: 0o600 });
+      chmodSync(outPath, 0o600); // belt-and-suspenders: guarantee 0600 regardless of umask/prior state
+    } catch (err) {
+      write(`dz sign --init: could not write the private key to ${outPath}: ${(err as Error).message}`);
+      return 1;
+    }
+    write(`dz sign --init: Ed25519 keypair generated.`);
+    write(`  private key → ${outPath} (mode 0600, OUTSIDE the repo — never commit it)`);
+    write(`  public key  → commit the block below as ${TRUST_ROOT_REL}:`);
+    write('');
+    write(publicKey.trimEnd());
+    write('');
+    write(`  then: dz sign --pack <dir> --key ${outPath}   (sign a pack)`);
+    return 0;
+  }
+
   const pack = options.get('pack');
   const key = options.get('key');
   if (!pack || !key) {
-    write('dz sign: --pack <dir> and --key <path> are both required');
+    write('dz sign: --pack <dir> and --key <path> are both required (or: dz sign --init to generate a keypair)');
     write('  the key path MUST be outside the repository working tree (a leaked signing key is not revertible)');
     return 1;
   }
@@ -3285,12 +3354,43 @@ function cmdVerifyPack(options: Map<string, string>, flags: Set<string>, cwd: st
   return 1;
 }
 
+/**
+ * `dz sbom` — emit a CycloneDX 1.5 SBOM (Software Bill of Materials) for a pack, standalone (no signing).
+ * The same inventory `dz sign` writes as `sbom.json`, available on its own for audit/procurement. Components
+ * are the pack's shipped files with their SHA-256 — a file-level bill of materials for the pack.
+ *   --pack <dir>   the pack to inventory (required)
+ *   --out <file>   write here (default: print to stdout)
+ *   --json         (implied) SPDX/CycloneDX is already JSON
+ */
+function cmdSbom(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
+  const pack = options.get('pack');
+  if (!pack) { write('dz sbom: --pack <dir> is required'); return 1; }
+  const packDir = resolve(cwd, pack);
+  if (!existsSync(packDir)) { write(`dz sbom: no such pack: ${packDir}`); return 1; }
+
+  const files = packFiles(packDir);
+  if (files.length === 0) { write('dz sbom: the pack contains no files'); return 1; }
+  const manifest = buildManifest(packDir, basename(packDir), files);
+  const sbom = buildSbom(manifest);
+  const out = JSON.stringify(sbom, null, 2);
+
+  const outOpt = options.get('out');
+  if (outOpt !== undefined) {
+    const outPath = resolve(cwd, outOpt);
+    try { writeFileSync(outPath, out + '\n'); } catch (err) { write(`dz sbom: could not write ${outPath}: ${(err as Error).message}`); return 1; }
+    write(`dz sbom: ${sbom.components.length} component(s) → ${outPath} (CycloneDX ${sbom.specVersion})`);
+    return 0;
+  }
+  write(out);
+  return 0;
+}
+
 function cmdPublish(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
   // Reject unknown flags/options so a typo (e.g. `--dry-rum`) can NEVER be
   // silently swallowed and flip the command into live-publish mode.
   const allowedFlags = new Set(['dry-run', 'no-dry-run', 'yes', 'confirm', 'bump-only', 'help', 'require-signing', 'provenance', 'no-provenance']);
-  const allowedOptions = new Set(['filter', 'claim-check']);
-  const allowedHelp = '  allowed: --dry-run (default), --yes/--confirm/--no-dry-run (go live), --bump-only, --filter <substr>, --claim-check <off|warn|error>';
+  const allowedOptions = new Set(['filter', 'claim-check', 'no-guard']);
+  const allowedHelp = '  allowed: --dry-run (default), --yes/--confirm/--no-dry-run (go live), --bump-only, --filter <substr>, --claim-check <off|warn|error>, --no-guard "<reason>" (skip the guard pre-flight; logged)';
   for (const flag of flags) {
     if (!allowedFlags.has(flag)) {
       write(`dz publish: unknown option --${flag}`);
@@ -3307,6 +3407,29 @@ function cmdPublish(options: Map<string, string>, flags: Set<string>, cwd: strin
     }
   }
 
+  // dz guard pre-flight (ADR-002 option A): publish is the most dangerous, least-reversible self-mutation, so
+  // it ALWAYS runs the declarative guard first. A HARD violation refuses the publish; `--no-guard "<reason>"`
+  // is the logged escape hatch (the override lands in .dz/guard-audit.jsonl — visible, never silent).
+  {
+    let guardRoot = cwd;
+    try { guardRoot = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf-8' }).trim() || cwd; } catch { /* not git */ }
+    const noGuard = options.get('no-guard');
+    if (noGuard !== undefined && noGuard.trim() === '') {
+      write('dz publish: --no-guard requires a reason (it is logged): --no-guard "hotfix, guard re-run after"');
+      return 1;
+    }
+    const guardResult = runGuardEvaluation(guardRoot, 'publish', undefined, noGuard);
+    if (guardResult.verdict === 'block' && noGuard === undefined) {
+      write('dz publish: ✗ BLOCKED by dz guard (HARD invariant violated):');
+      for (const v of guardResult.violations.filter((x) => x.severity === 'hard')) write(`  [BLOCK] ${v.rule}: ${v.detail}`);
+      write('  → fix the violation(s), or override with --no-guard "<reason>" (logged to .dz/guard-audit.jsonl).');
+      return 1;
+    }
+    if (guardResult.verdict === 'block') write(`dz publish: ⚠ guard BLOCK overridden via --no-guard: ${noGuard} (logged)`);
+    else if (guardResult.verdict === 'warn') for (const v of guardResult.violations) write(`dz publish: ⚠ guard warn — ${v.rule}: ${v.detail}`);
+    else write('dz publish: ✓ guard pre-flight passed');
+  }
+
   // ADR-001 (publish-provenance): decide BEFORE any work — flag validation, then a pre-flight that
   // refuses `--provenance` where no OIDC token can be minted. `off` is an escape hatch that names itself.
   if (flags.has('provenance') && flags.has('no-provenance')) {
@@ -4062,33 +4185,202 @@ function cmdDriftCheck(options: Map<string, string>, flags: Set<string>, cwd: st
     write(`allowlisted (accepted drift): ${r.allowlisted.map((d) => d.name).join(', ')}`);
   }
   write(`DRIFTED (unexpected, byte-differences between copies): ${r.drifted.length}`);
+  let driftExit = 0;
   if (r.drifted.length === 0) {
     write('✓ no unexpected intra-monorepo skill drift');
-    return 0;
+  } else {
+    write('');
+    write('skill'.padEnd(34) + 'copies  drift/total');
+    for (const d of r.drifted) {
+      write(
+        d.name.padEnd(34) +
+          String(d.copies).padStart(4) +
+          '    ' +
+          `${d.driftFiles}/${d.totalFiles}` +
+          (d.missingFiles ? ` (+${d.missingFiles} missing)` : ''),
+      );
+    }
+    write('');
+    write('→ fix each: heal drift, then commit. Remediation per skill:');
+    for (const d of r.drifted) {
+      const hasMeta = existsSync(join(root, 'packages', '@dzhechkov', 'skills-meta', d.name));
+      write(
+        hasMeta
+          ? `    dz sync-canonical ${d.name}`
+          : `    dz sync-canonical ${d.name} --from <a-known-good-copy>   (no skills-meta canonical)`,
+      );
+    }
+    write('  (accept a drift intentionally: add its name to .dz/drift-allowlist.json with a reason)');
+    driftExit = 1; // EXIT CODE 1 = the CI gate trips
   }
+  // Supplementary CI check: installed-pack signatures. A TAMPERED pack trips the gate (fatal); an unsigned
+  // pack or a missing trust root is reported, not fatal — the same warn/block posture as `dz doctor` (the
+  // primary signature gate). drift-check surfaces it so the CI drift view also flags a tampered pack.
   write('');
-  write('skill'.padEnd(34) + 'copies  drift/total');
-  for (const d of r.drifted) {
-    write(
-      d.name.padEnd(34) +
-        String(d.copies).padStart(4) +
-        '    ' +
-        `${d.driftFiles}/${d.totalFiles}` +
-        (d.missingFiles ? ` (+${d.missingFiles} missing)` : ''),
-    );
+  const sigFatal = reportPackVerification(root, options.get('pubkey'), flags.has('require-signing'), write);
+  return driftExit || sigFatal;
+}
+
+const DEFAULT_STORE_CAP = 5000;
+
+/** Read the optional `.dz/guard.json` — `{ rules?: [...], storeCap?: number }`. Missing/broken ⇒ defaults. */
+function loadGuardConfig(root: string): { rules?: unknown[]; storeCap?: number } {
+  const p = join(root, '.dz', 'guard.json');
+  if (!existsSync(p)) return {};
+  try {
+    const j = JSON.parse(readFileSync(p, 'utf8'));
+    return j && typeof j === 'object' ? j : {};
+  } catch { return {}; }
+}
+
+/** Extract labelled (a,b) count pairs from the READMEs that must agree (the parity invariant, inline). */
+function gatherReadmeCounts(root: string): { label: string; a: number; b: number }[] {
+  const read = (rel: string): string => { try { return readFileSync(join(root, rel), 'utf8'); } catch { return ''; } };
+  const rootMd = read('README.md');
+  const cliMd = read('packages/@dzhechkov/harness-cli/README.md');
+  const num = (s: string, re: RegExp): number | null => { const m = s.match(re); return m && m[1] ? Number(m[1]) : null; };
+  const pairs: { label: string; a: number; b: number }[] = [];
+  const cjm = num(rootMd, /## User Journey — 6 phases, (\d+) commands/);
+  const cliAll = num(cliMd, /## All Commands \((\d+)\)/);
+  const rootAll = num(rootMd, /## All Commands \((\d+)\)/);
+  if (cjm !== null && cliAll !== null) pairs.push({ label: 'commands (root CJM header vs cli All Commands)', a: cjm, b: cliAll });
+  if (rootAll !== null && cliAll !== null) pairs.push({ label: 'All Commands (root vs cli)', a: rootAll, b: cliAll });
+  return pairs;
+}
+
+/** Gather the facts one op needs. All I/O is best-effort — a missing signal skips its rule, never crashes. */
+function gatherGuardFacts(op: string, root: string, text: string | undefined, storeCap: number): Record<string, unknown> {
+  const facts: Record<string, unknown> = { op };
+  if (op === 'publish') {
+    // Read every workspace manifest ONCE: build a name→version map, then resolve each `workspace:*` dep to the
+    // version pnpm WOULD publish it as. In a pnpm workspace (pnpm-workspace.yaml present) `workspace:*` in source
+    // is correct and gets rewritten at publish — so reporting it raw would be a FALSE gate. We mirror the rewrite:
+    // a resolvable workspace dep becomes its real semver (safe → the rule passes); an UNRESOLVABLE one (points at
+    // no workspace package, or not a pnpm workspace) stays `workspace:*` so the rule catches a dep that WOULD ship
+    // raw. That is the genuinely dangerous case the rule exists for.
+    const manifests: { name?: string; version?: string; private?: boolean; dependencies?: Record<string, string> }[] = [];
+    try {
+      const out = execSync('git ls-files "packages/@dzhechkov/*/package.json"', { cwd: root, encoding: 'utf-8' });
+      for (const rel of out.split('\n').map((s) => s.trim()).filter(Boolean)) {
+        try { manifests.push(JSON.parse(readFileSync(join(root, rel), 'utf8')) as typeof manifests[number]); } catch { /* skip unreadable */ }
+      }
+    } catch { /* not a git repo */ }
+    const versionByName = new Map<string, string>();
+    for (const m of manifests) if (m.name && typeof m.version === 'string') versionByName.set(m.name, m.version);
+    const pnpmWorkspace = existsSync(join(root, 'pnpm-workspace.yaml'));
+    const packages: { name: string; deps: Record<string, string> }[] = [];
+    for (const m of manifests) {
+      if (m.private === true) continue; // unpublished packages are exempt
+      const deps: Record<string, string> = {};
+      for (const [dep, spec] of Object.entries(m.dependencies ?? {})) {
+        deps[dep] = (typeof spec === 'string' && spec.startsWith('workspace:') && pnpmWorkspace && versionByName.has(dep))
+          ? versionByName.get(dep)! // pnpm rewrites this to a real semver at publish → safe
+          : spec; // non-pnpm, or an unresolvable workspace dep → keep raw so the rule catches a would-ship-raw dep
+      }
+      packages.push({ name: m.name ?? '(unnamed)', deps });
+    }
+    facts['packages'] = packages;
+    try { facts['drift'] = sweepSkillDrift(root, { scope: 'packages', allowlist: readDriftAllowlist(root) }).drifted.map((d) => d.name); } catch { /* skip */ }
+    facts['counts'] = gatherReadmeCounts(root);
   }
-  write('');
-  write('→ fix each: heal drift, then commit. Remediation per skill:');
-  for (const d of r.drifted) {
-    const hasMeta = existsSync(join(root, 'packages', '@dzhechkov', 'skills-meta', d.name));
-    write(
-      hasMeta
-        ? `    dz sync-canonical ${d.name}`
-        : `    dz sync-canonical ${d.name} --from <a-known-good-copy>   (no skills-meta canonical)`,
-    );
+  if (op === 'consolidate') {
+    try { facts['drift'] = sweepSkillDrift(root, { scope: 'packages', allowlist: readDriftAllowlist(root) }).drifted.map((d) => d.name); } catch { /* skip */ }
+  }
+  if (op === 'teach' || op === 'consolidate') {
+    if (op === 'teach' && text) facts['secretTargets'] = [{ label: 'lesson', text }];
+    let count = 0;
+    try { count = loadStorePatternsSync(root).length; } catch { /* skip → cap never trips */ count = 0; }
+    facts['store'] = { count, cap: storeCap };
   }
-  write('  (accept a drift intentionally: add its name to .dz/drift-allowlist.json with a reason)');
-  return 1; // EXIT CODE 1 = the CI gate trips
+  return facts;
+}
+
+/**
+ * Load config → resolve rules → gather facts → evaluate → append the audit record. The ONE evaluation path,
+ * shared by `dz guard check` and the `dz publish` pre-flight (ADR-002 option A) so they can never disagree.
+ * `overrideReason` (when the caller forces through a block) is logged, never silent.
+ */
+function runGuardEvaluation(root: string, op: string, text: string | undefined, overrideReason: string | undefined): ReturnType<typeof evaluateGuard> {
+  const cfg = loadGuardConfig(root);
+  // Number.isFinite, not just > 0: a config `storeCap: 1e400` parses to Infinity, passes `> 0`, and would
+  // silently DISABLE the cap (count <= Infinity always). Non-finite ⇒ fall back to the default.
+  const storeCap = typeof cfg.storeCap === 'number' && Number.isFinite(cfg.storeCap) && cfg.storeCap > 0 ? cfg.storeCap : DEFAULT_STORE_CAP;
+  const rules = resolveRules(Array.isArray(cfg.rules) ? (cfg.rules as never[]) : undefined);
+  const facts = gatherGuardFacts(op, root, text, storeCap);
+  const result = evaluateGuard(facts as never, rules);
+  // audit (append-only). ts is real time here (a CLI, not the sandboxed workflow).
+  try {
+    const rec = auditRecord(result, new Date().toISOString(), overrideReason !== undefined ? { reason: overrideReason } : undefined);
+    mkdirSync(join(root, '.dz'), { recursive: true });
+    writeFileSync(join(root, '.dz', 'guard-audit.jsonl'), JSON.stringify(rec) + '\n', { flag: 'a' });
+  } catch { /* audit is best-effort, never blocks the verdict */ }
+  return result;
+}
+
+/**
+ * `dz guard` — the declarative constraint layer that refuses a self-mutating op when a HARD invariant is
+ * violated. Simple outside: `dz guard check --op publish` works with zero config (built-in defaults).
+ *   check --op <publish|teach|consolidate|reindex> [--text <s>] [--json] [--force <reason>]
+ *   --init     scaffold an editable .dz/guard.json (only if you want to customise)
+ *   log [--limit N]   tail the append-only .dz/guard-audit.jsonl
+ * Exit 1 on a HARD block (0 with --force <reason>, which is logged); 0 on warn/pass.
+ */
+function cmdGuard(options: Map<string, string>, flags: Set<string>, cwd: string, write: Write): number {
+  let root = cwd;
+  try { root = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf-8' }).trim() || cwd; } catch { /* not git */ }
+  const sub = options.get('_positional_0') ?? 'check';
+
+  if (flags.has('init') || sub === 'init') {
+    const p = join(root, '.dz', 'guard.json');
+    if (existsSync(p) && !flags.has('force')) { write(`dz guard --init: ${p} already exists (pass --force to overwrite)`); return 1; }
+    const scaffold = {
+      storeCap: DEFAULT_STORE_CAP,
+      rules: DEFAULT_RULES.map((r) => ({ id: r.id, severity: r.severity, enabled: true, description: r.description })),
+    };
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, JSON.stringify(scaffold, null, 2) + '\n');
+    write(`dz guard --init: wrote ${p} (edit severity/enabled to customise; delete it to return to built-in defaults)`);
+    return 0;
+  }
+
+  if (sub === 'log') {
+    const p = join(root, '.dz', 'guard-audit.jsonl');
+    if (!existsSync(p)) { write('dz guard log: no audit yet (.dz/guard-audit.jsonl)'); return 0; }
+    const limit = Math.max(1, Number(options.get('limit') ?? '20') || 20);
+    // parse-filter BEFORE emitting: a corrupt line must not make the --json output invalid JSON.
+    const rows = readFileSync(p, 'utf8').split('\n').filter(Boolean).slice(-limit)
+      .map((row) => { try { return JSON.parse(row) as { ts: string; op: string; verdict: string; override?: { reason: string } }; } catch { return null; } })
+      .filter((r): r is { ts: string; op: string; verdict: string; override?: { reason: string } } => r !== null);
+    if (flags.has('json')) { write(JSON.stringify(rows)); return 0; }
+    for (const r of rows) {
+      write(`${r.ts}  ${String(r.op).padEnd(11)} ${String(r.verdict).toUpperCase()}${r.override ? `  (forced: ${r.override.reason})` : ''}`);
+    }
+    return 0;
+  }
+
+  if (sub !== 'check') {
+    write(`dz guard: unknown subcommand '${sub}' — use: check --op <op> | --init | log`);
+    return 1;
+  }
+
+  // check
+  const op = options.get('op');
+  if (op === undefined || !['publish', 'teach', 'consolidate', 'reindex'].includes(op)) {
+    write('dz guard check: --op must be one of publish | teach | consolidate | reindex');
+    return 1;
+  }
+  const force = options.get('force');
+  const forced = force !== undefined;
+  const result = runGuardEvaluation(root, op, options.get('text'), force);
+
+  if (flags.has('json')) { write(JSON.stringify({ ...result, forced }, null, 2)); return guardExitCode(result, forced); }
+
+  const glyph = result.verdict === 'block' ? '✗' : result.verdict === 'warn' ? '⚠' : '✓';
+  write(`dz guard (${op}): ${glyph} ${result.verdict.toUpperCase()}  [checked: ${result.checked.join(', ') || 'no rules for this op'}]`);
+  for (const v of result.violations) write(`  [${v.severity === 'hard' ? 'BLOCK' : 'warn'}] ${v.rule}: ${v.detail}`);
+  if (result.verdict === 'block' && forced) write(`  → forced through: ${force} (logged to .dz/guard-audit.jsonl)`);
+  else if (result.verdict === 'block') write('  → blocked. Fix the HARD violation(s), or override with --force "<reason>" (logged).');
+  return guardExitCode(result, forced);
 }
 
 /**
@@ -5065,6 +5357,10 @@ export async function runCli(argv: string[], io: CliIo = {}): Promise<number> {
         return cmdClaimCheck(options, optionLists, flags, cwd, write);
       case 'sign':
         return cmdSign(options, flags, cwd, write);
+      case 'sbom':
+        return cmdSbom(options, flags, cwd, write);
+      case 'guard':
+        return cmdGuard(options, flags, cwd, write);
       case 'verify-pack':
         return cmdVerifyPack(options, flags, cwd, write);
       case 'setup':