mneme-ai 2.55.0 → 2.57.0

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAuIA,wBAAsB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA6gKvD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAuIA,wBAAsB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAwxKvD"}

package/dist/index.js

@@ -4715,6 +4715,340 @@ export async function run(argv) {
             process.exitCode = 1;
         }
     });
+    // v2.56.0 — xAI / GROK / SpaceX ALIGNMENT — 3 wild primitives.
+    const launchParent = program
+        .command("launch_window")
+        .description("🚀 v2.56 — SpaceX-style GO/NO-GO release verdict aggregator. Runs TRUTH GATE + PEAK GAUNTLET subset + PERF BUDGET + INDISPENSABILITY + WIRING LAG + PROBE COVERAGE + SDK BUILT gates → single status + HMAC certificate.")
+        .option("--fast", "skip slow gates (truth_gate subset)", false)
+        .action(async (opts) => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const v = await core.xaiAlignment.evaluateLaunchWindow({ cwd: process.cwd(), fast: opts.fast ?? false });
+            process.stdout.write(JSON.stringify(v, null, 2) + "\n");
+            process.stderr.write(core.xaiAlignment.renderLaunchBanner(v) + "\n");
+            if (v.status !== "GO")
+                process.exitCode = 1;
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    launchParent.command("check")
+        .description("Alias for `mneme launch_window` default action.")
+        .option("--fast", "skip slow gates", false)
+        .action(async (opts) => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const v = await core.xaiAlignment.evaluateLaunchWindow({ cwd: process.cwd(), fast: opts.fast ?? false });
+            process.stdout.write(JSON.stringify(v, null, 2) + "\n");
+            if (v.status !== "GO")
+                process.exitCode = 1;
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    const dragonParent = program
+        .command("dragon")
+        .description("🔥 v2.56 — emergency rollback primitive (DRAGON EJECT). Use `mneme dragon eject <commit> --rationale '...' [--confirm]`.");
+    dragonParent.command("eject <commit>")
+        .description("Eject (revert) a doomed commit + emit GAVEL-grade forensic bundle. Dry-run by default; --confirm to execute.")
+        .requiredOption("--rationale <text>", "WHY are we ejecting? (one-line audit trail)")
+        .option("--probe <id...>", "Failing probe id(s)")
+        .option("--test <id...>", "Failing test id(s)")
+        .option("--perf <op...>", "Perf budget violation(s)")
+        .option("--confirm", "Execute the real eject (default: dry-run)", false)
+        .action(async (commit, opts) => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const r = core.xaiAlignment.dragonEject({
+                repoRoot: process.cwd(),
+                commit,
+                reason: {
+                    rationale: opts.rationale,
+                    failingProbes: opts.probe ?? [],
+                    failingTests: opts.test ?? [],
+                    perfViolations: opts.perf ?? [],
+                },
+                dryRun: !opts.confirm,
+                confirm: opts.confirm ?? false,
+            });
+            process.stdout.write(JSON.stringify(r, null, 2) + "\n");
+            if (!r.ok)
+                process.exitCode = 1;
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    dragonParent.command("chain")
+        .description("Verify the DRAGON eject ledger HMAC chain.")
+        .action(async () => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const chain = core.xaiAlignment.verifyDragonChain(process.cwd());
+            const events = core.xaiAlignment.listEjects(process.cwd());
+            process.stdout.write(JSON.stringify({ ok: chain.ok, chain, eventCount: events.length, events }, null, 2) + "\n");
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    const stargateParent = program
+        .command("stargate")
+        .description("🛡 v2.56 — open-source publish of the augmented calibration corpus (MIT-licensed). Make Mneme the Switzerland of AI vendor identity verification.");
+    stargateParent.command("publish")
+        .description("Build + (optionally) write the corpus bundle. Use --out <path> + --format json|jsonl|md.")
+        .option("--out <path>", "Output file path")
+        .option("--format <fmt>", "Output format: json | jsonl | md", "json")
+        .option("--version <v>", "Mneme version label for the bundle", "2.56.0")
+        .action(async (opts) => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const r = core.xaiAlignment.publishStargate({
+                outPath: opts.out,
+                format: opts.format ?? "json",
+                mnemeVersion: opts.version ?? "2.56.0",
+            });
+            const { bundle, ...rest } = r;
+            process.stdout.write(JSON.stringify({ ...rest, fixtureCount: bundle?.fixtureCount, vendors: bundle?.vendors, augmentationKinds: bundle?.augmentationKinds, contentSha256: bundle?.contentSha256, hmac: bundle?.hmac, citation: bundle?.citation, fixturesPreview: bundle?.fixtures.slice(0, 1) }, null, 2) + "\n");
+            if (!r.ok)
+                process.exitCode = 1;
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    stargateParent.command("verify")
+        .description("Verify a STARGATE bundle envelope offline. Use --stdin.")
+        .option("--stdin", "Read bundle JSON from stdin")
+        .action(async () => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const chunks = [];
+            for await (const c of process.stdin)
+                chunks.push(c);
+            const body = Buffer.concat(chunks).toString("utf8").trim();
+            if (!body) {
+                process.stdout.write(JSON.stringify({ ok: false, error: "pass bundle JSON via stdin" }) + "\n");
+                process.exitCode = 1;
+                return;
+            }
+            const r = core.xaiAlignment.verifyStargateBundle(JSON.parse(body));
+            process.stdout.write(JSON.stringify(r, null, 2) + "\n");
+            if (!r.ok)
+                process.exitCode = 1;
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    // ──────────────────────────────────────────────────────────────────
+    //  v2.57.0 — Top-level surface promotion (no `nemesis` prefix needed)
+    //  + WIRING DOCTOR primitive (AST-level per-feature check)
+    // ──────────────────────────────────────────────────────────────────
+    // 🧠 LETHE top-level alias
+    const letheParent = program
+        .command("lethe")
+        .description("🧠 v2.57 — LETHE alias (forwards to `mneme nemesis lethe_forget`). GDPR Art 17 forget primitive.");
+    letheParent.command("forget")
+        .description("Forget a row from a JSONL ledger. Use --ledger <p> --row <n> [--dry-run].")
+        .requiredOption("--ledger <p>", "Repo-relative ledger path")
+        .requiredOption("--row <n>", "Row index (0-based)", (v) => Number(v))
+        .option("--jurisdiction <t>", "GDPR jurisdiction tag", "EU-GDPR-Art17")
+        .option("--dry-run", "Build receipt without rewriting", false)
+        .action(async (opts) => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const r = core.nemesis.forgetRow({ repoRoot: process.cwd(), ledgerRelative: opts.ledger, rowIndex: opts.row, jurisdiction: opts.jurisdiction, dryRun: opts.dryRun ?? false });
+            process.stdout.write(JSON.stringify(r, null, 2) + "\n");
+            if (!r.ok)
+                process.exitCode = 1;
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    letheParent.command("verify")
+        .description("Verify a ForgetReceipt cryptographically. Use --stdin.")
+        .option("--stdin", "Read receipt JSON from stdin")
+        .action(async () => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const chunks = [];
+            for await (const c of process.stdin)
+                chunks.push(c);
+            const body = Buffer.concat(chunks).toString("utf8").trim();
+            if (!body) {
+                process.stdout.write(JSON.stringify({ ok: false, error: "pass receipt JSON via stdin" }) + "\n");
+                process.exitCode = 1;
+                return;
+            }
+            const v = core.nemesis.verifyForgetReceipt(JSON.parse(body));
+            process.stdout.write(JSON.stringify(v, null, 2) + "\n");
+            if (!v.ok)
+                process.exitCode = 1;
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    // ⚖ GAVEL top-level alias
+    const gavelParent = program
+        .command("gavel")
+        .description("⚖ v2.57 — GAVEL alias (forwards to `mneme nemesis gavel_pack/verify`). Court-admissible bundle.");
+    gavelParent.command("pack")
+        .description("Bind THEMIS + EU stamp + SIBYL into court-admissible Merkle bundle. Use --stdin.")
+        .option("--stdin", "Read bundle input JSON from stdin")
+        .action(async () => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const chunks = [];
+            for await (const c of process.stdin)
+                chunks.push(c);
+            const body = Buffer.concat(chunks).toString("utf8").trim();
+            if (!body) {
+                process.stdout.write(JSON.stringify({ ok: false, error: "pass bundle input JSON via stdin" }) + "\n");
+                process.exitCode = 1;
+                return;
+            }
+            const r = core.nemesis.buildGavelBundle(JSON.parse(body));
+            process.stdout.write(JSON.stringify(r, null, 2) + "\n");
+            if (!r.ok)
+                process.exitCode = 1;
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    gavelParent.command("verify")
+        .description("Verify bundle HMAC + Merkle root + per-artifact signature. Use --stdin.")
+        .option("--stdin", "Read bundle JSON from stdin")
+        .action(async () => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const chunks = [];
+            for await (const c of process.stdin)
+                chunks.push(c);
+            const body = Buffer.concat(chunks).toString("utf8").trim();
+            if (!body) {
+                process.stdout.write(JSON.stringify({ ok: false, error: "pass bundle JSON via stdin" }) + "\n");
+                process.exitCode = 1;
+                return;
+            }
+            const v = core.nemesis.verifyGavelBundle(JSON.parse(body));
+            process.stdout.write(JSON.stringify(v, null, 2) + "\n");
+            if (!v.ok)
+                process.exitCode = 1;
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    // 🌐 NIMBUS top-level alias
+    const nimbusParent = program
+        .command("nimbus")
+        .description("🌐 v2.57 — NIMBUS alias (forwards to `mneme nemesis nimbus_*`). Federated trust mesh.");
+    nimbusParent.command("publish")
+        .description("Publish leaderboard card to local pub-store. Use --stdin or --org-tag.")
+        .option("--stdin", "Read publish input JSON from stdin")
+        .option("--org-tag <name>", "Org tag (alternative to --stdin)")
+        .action(async (opts) => {
+        try {
+            const core = await import("@mneme-ai/core");
+            let j = null;
+            if (opts.stdin) {
+                const chunks = [];
+                for await (const c of process.stdin)
+                    chunks.push(c);
+                const body = Buffer.concat(chunks).toString("utf8").trim();
+                if (body)
+                    j = JSON.parse(body);
+            }
+            const orgTag = opts.orgTag ?? j?.orgTag;
+            if (!orgTag) {
+                process.stdout.write(JSON.stringify({ ok: false, error: "orgTag required (--org-tag or via stdin)" }) + "\n");
+                process.exitCode = 1;
+                return;
+            }
+            const input = { ...(j ?? {}), repoRoot: process.cwd(), orgTag };
+            const r = core.nemesis.publishCard(input);
+            process.stdout.write(JSON.stringify(r, null, 2) + "\n");
+            if (!r.ok)
+                process.exitCode = 1;
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    nimbusParent.command("subscribe")
+        .description("Subscribe to foreign org's card. Verifies HMAC + expiry. --trust <0..1> optional.")
+        .option("--stdin", "Read card JSON from stdin")
+        .option("--trust <n>", "Local trust weight (0..1)", (v) => Number(v), 0.5)
+        .action(async (opts) => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const chunks = [];
+            for await (const c of process.stdin)
+                chunks.push(c);
+            const body = Buffer.concat(chunks).toString("utf8").trim();
+            if (!body) {
+                process.stdout.write(JSON.stringify({ ok: false, error: "pass card JSON via stdin" }) + "\n");
+                process.exitCode = 1;
+                return;
+            }
+            const r = core.nemesis.subscribeCard({ repoRoot: process.cwd(), card: JSON.parse(body), trustWeight: opts.trust });
+            process.stdout.write(JSON.stringify(r, null, 2) + "\n");
+            if (!r.ok)
+                process.exitCode = 1;
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    nimbusParent.command("reputation")
+        .description("Compute cross-org weighted vendor reputation from subscribed cards.")
+        .action(async () => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const r = core.nemesis.computeCrossOrgReputation(process.cwd());
+            process.stdout.write(JSON.stringify({ ok: true, vendors: r }, null, 2) + "\n");
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    // 🤯 WIRING DOCTOR — AST-level per-feature surface check
+    program
+        .command("wiring_doctor")
+        .description("🤯 v2.57 — WIRING DOCTOR: scan core / sdk / cli source for per-feature surface coverage (core export · SDK method · CLI verb · TG claim). Replaces commit-msg parsing with structural verification.")
+        .option("--features <list...>", "Features to check (default: lethe / gavel / nimbus / janus / stargate / dragon / launch_window)")
+        .action(async (opts) => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const r = core.wiringDoctor.diagnose(process.cwd(), { features: opts.features });
+            process.stdout.write(JSON.stringify(r, null, 2) + "\n");
+            if (!r.ok)
+                process.exitCode = 1;
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
     // v2.53.0 — CATALOG COUNT single source of truth.
     const catalogParent = program
         .command("catalog")