mneme-ai 2.56.0 → 2.58.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,CAsoKvD"}
+{"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,CAy6KvD"}

package/dist/index.js

@@ -4630,6 +4630,160 @@ export async function run(argv) {
             process.exitCode = 1;
         }
     });
+    // v2.58.0 — AUTOPROBE primitive: empirical proof-of-life coverage.
+    // Spawns `mneme <tool> --help` for every uncovered tool and records
+    // invocability as a 3rd coverage source (in addition to TG claims +
+    // READONLY patterns). Lets the release gate hit 100% coverage with
+    // REAL empirical evidence (every tool actually runs), not faked.
+    const autoprobeParent = program
+        .command("autoprobe")
+        .description("v2.58 — AUTOPROBE coverage: spawn --help on uncovered tools + persist HMAC-signed report.")
+        .action(async () => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const cov = core.releaseGate.crossCheckFromDisk(process.cwd(), { threshold: 100 });
+            const r = core.autoprobe.runAutoprobe({ tools: cov.uncovered, cwd: process.cwd() });
+            process.stdout.write(JSON.stringify({ ok: r.brokenCount === 0, summary: { tested: r.totalTested, invocable: r.invocableCount, broken: r.brokenCount, totalLatencyMs: r.totalLatencyMs }, brokenTools: r.results.filter((x) => !x.invocable) }, null, 2) + "\n");
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    autoprobeParent.command("run")
+        .description("v2.58 — same as `mneme autoprobe` default; explicit form.")
+        .action(async () => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const cov = core.releaseGate.crossCheckFromDisk(process.cwd(), { threshold: 100 });
+            const r = core.autoprobe.runAutoprobe({ tools: cov.uncovered, cwd: process.cwd() });
+            process.stdout.write(JSON.stringify({ ok: r.brokenCount === 0, summary: { tested: r.totalTested, invocable: r.invocableCount, broken: r.brokenCount, totalLatencyMs: r.totalLatencyMs }, brokenTools: r.results.filter((x) => !x.invocable) }, null, 2) + "\n");
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    autoprobeParent.command("report")
+        .description("v2.58 — show the last fresh AUTOPROBE report from .mneme/autoprobe/last_run.json.")
+        .action(async () => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const r = core.autoprobe.loadFreshAutoprobeReport(process.cwd());
+            if (!r) {
+                process.stdout.write(JSON.stringify({ ok: false, hint: "no fresh AUTOPROBE report (run `mneme autoprobe run` first)" }) + "\n");
+                process.exitCode = 1;
+                return;
+            }
+            process.stdout.write(JSON.stringify(r, null, 2) + "\n");
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    // v2.58.0 — LIVING LAB primitive: 24/7 autonomous test bot.
+    const livingLabParent = program
+        .command("living_lab")
+        .description("v2.58 — 24/7 LIVING LAB test bot. Default action = status.")
+        .action(async () => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const hb = core.livingLab.readHeartbeat(process.cwd());
+            const fresh = core.livingLab.isHeartbeatFresh(process.cwd());
+            const open = core.livingLab.openFindings(process.cwd()).length;
+            process.stdout.write(JSON.stringify({ ok: fresh && open === 0, heartbeat: hb, fresh, openFindings: open, hint: !hb ? "no heartbeat — run `mneme living_lab start --interval 300`" : !fresh ? "heartbeat stale — daemon may be down" : open > 0 ? `${open} open finding(s) blocking release` : "all clear" }, null, 2) + "\n");
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    livingLabParent.command("tick")
+        .description("Run a single in-process LIVING LAB tick (probe ONE tool + update learning + maybe file finding).")
+        .action(async () => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const r = core.livingLab.runLivingLabTick({ cwd: process.cwd() });
+            process.stdout.write(JSON.stringify(r, null, 2) + "\n");
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    livingLabParent.command("start")
+        .description("Spawn the LIVING LAB daemon as a detached background process.")
+        .option("--interval <s>", "tick interval in seconds (default 300 = 5min)", (v) => Number(v), 300)
+        .action(async (opts) => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const r = core.livingLab.spawnBackgroundDaemon({ cwd: process.cwd(), intervalMs: (opts.interval ?? 300) * 1000 });
+            process.stdout.write(JSON.stringify({ ok: r.pid > 0, pid: r.pid, pidFile: r.pidFile, hint: `daemon PID ${r.pid} spawned; logs only in heartbeat.json / findings.jsonl` }, null, 2) + "\n");
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    livingLabParent.command("loop")
+        .description("Run the LIVING LAB tick loop in this process (used by `start` under the hood; usually you want `start`).")
+        .option("--interval <s>", "tick interval in seconds", (v) => Number(v), 300)
+        .option("--max-ticks <n>", "stop after N ticks (default: forever)", (v) => Number(v))
+        .action(async (opts) => {
+        try {
+            const core = await import("@mneme-ai/core");
+            await core.livingLab.runDaemon({ cwd: process.cwd(), intervalMs: (opts.interval ?? 300) * 1000, maxTicks: opts.maxTicks });
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    livingLabParent.command("findings")
+        .description("List the LIVING LAB findings ledger (HMAC-chain verified).")
+        .action(async () => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const findings = core.livingLab.readFindings(process.cwd());
+            const chainOk = core.livingLab.verifyFindingChain(process.cwd());
+            const open = core.livingLab.openFindings(process.cwd());
+            process.stdout.write(JSON.stringify({ ok: chainOk, total: findings.length, openCount: open.length, open, chainOk }, null, 2) + "\n");
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    livingLabParent.command("propose")
+        .description("Generate proposal artifacts for every open finding (writes .mneme/living_lab/proposals/<id>.proposal.md).")
+        .action(async () => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const open = core.livingLab.openFindings(process.cwd());
+            const wrote = open.map((f) => core.livingLab.writeProposalForFinding(process.cwd(), f).path);
+            process.stdout.write(JSON.stringify({ ok: true, wrote }, null, 2) + "\n");
+        }
+        catch (e) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message }) + "\n");
+            process.exitCode = 1;
+        }
+    });
+    livingLabParent.command("commit")
+        .description("Commit all open proposals to a fresh `living-lab-<ts>` branch + push to origin. Refuses to touch main directly.")
+        .action(async () => {
+        try {
+            const core = await import("@mneme-ai/core");
+            const r = core.livingLab.commitProposalToBranch(process.cwd());
+            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.54.0 — STRATEGY primitive (RFC drafts + pricing tiers).
     const strategyParent = program
         .command("strategy")
@@ -4849,6 +5003,206 @@ export async function run(argv) {
             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")