@tachikomagundam/abathur 0.1.0

package/dist/core/bundle-export.js

@@ -0,0 +1,212 @@
+// `abathur bundle export` (todo 12): assemble a self-describing, redacted lineage
+// bundle. All generation content is read from GIT OBJECTS at the gen commit
+// (`git archive`, argv-only) — the worktree is never consulted, so a dirty
+// worktree is impossible by construction. Stats/verdict/counters/provenance are
+// copied from the LEDGER row (single source of truth); fingerprints are
+// recomputed from the shipped content. Nothing reaches disk unless every member
+// passes the whole-bundle leak scan; the write itself is tmp-file + rename.
+import { execFile } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { blocked, cannotAnswer } from "../exit.js";
+import { tryGit } from "../util/git.js";
+import { Ledger } from "./ledger.js";
+import { decodeGenerationRecord } from "./evolve/run-rows.js";
+import { LEDGER_KIND_GENERATION_COMPLETE } from "./ledger.js";
+import { fingerprint } from "./ids.js";
+import { benchDigestFor, containedSpec, EVIDENCE_CAP_BYTES, EVIDENCE_PREFIX, maskPlanFor, PATH_SAFE, primaryGenId, repOfRunId, sha256Hex, } from "./bundle-common.js";
+import { lineageEntry, renderReadme, deriveBenchProvenance, DIGEST_ALGO, BUNDLE_SCHEMA_VERSION } from "./bundle-manifest.js";
+import { scanMemberLeaks } from "./bundle-mask.js";
+import { readTar, writeTar } from "./bundle-tar.js";
+const COMMIT_RE = /^[0-9a-f]{7,64}$/;
+function candidateRowsByGenId(genomeRepo) {
+    const latest = new Map();
+    for (const record of Ledger.open(genomeRepo).readAll()) {
+        if (record.kind !== LEDGER_KIND_GENERATION_COMPLETE || record.genId === undefined)
+            continue;
+        const data = decodeGenerationRecord(record);
+        if (data.source !== "candidate")
+            continue;
+        latest.set(record.genId, data);
+    }
+    return [...latest.entries()].map(([genId, data]) => ({ genId, data }));
+}
+function selectGens(rows, select) {
+    if ("genIds" in select) {
+        const byId = new Map(rows.map((r) => [r.genId, r]));
+        const picked = [];
+        for (const id of select.genIds) {
+            const row = byId.get(id);
+            if (row === undefined) {
+                cannotAnswer(`bundle export: no candidate generation_complete row for genId '${id}' in this ledger`, "list history with 'abathur status'");
+            }
+            if (!picked.some((r) => r.genId === id))
+                picked.push(row);
+        }
+        return picked;
+    }
+    if (!Number.isInteger(select.last) || select.last < 1)
+        cannotAnswer(`bundle export: --last must be a positive integer, got ${String(select.last)}`);
+    return rows.slice(-select.last);
+}
+/** Generation tree bytes via `git archive` — stdout is binary, so util/git's
+ *  string contract does not apply; same argv-only + timeout + LC_ALL=C guards. */
+async function gitTree(repoPath, genId, commit) {
+    if (!COMMIT_RE.test(commit))
+        cannotAnswer(`bundle export: ledger gen ${genId} carries a non-commit value '${commit}'`);
+    const bytes = await new Promise((resolve, reject) => {
+        execFile("git", ["-C", repoPath, "archive", "--format=tar", commit], { timeout: 30_000, killSignal: "SIGKILL", maxBuffer: 64 * 1024 * 1024, encoding: "buffer", env: { ...process.env, LC_ALL: "C" } }, (err, stdout) => (err === null ? resolve(new Uint8Array(stdout)) : reject(err)));
+    }).catch((err) => {
+        const why = err instanceof Error ? err.message.split("\n")[0] : String(err);
+        return blocked(`bundle export: gen ${genId} commit ${commit} unreadable from local git: ${why}`, "fetch the gen commit before exporting");
+    });
+    try {
+        const tree = new Map();
+        for (const m of readTar(bytes)) {
+            if (m.path === ".state" || m.path.startsWith(".state/"))
+                continue;
+            tree.set(m.path, m.content);
+        }
+        return tree;
+    }
+    catch (cause) {
+        return blocked(`bundle export: git archive output for gen ${genId} is not readable as tar: ${cause instanceof Error ? cause.message : String(cause)}`);
+    }
+}
+function findTranscript(sandboxBase, genId, dirName, unitId) {
+    let invs;
+    try {
+        invs = readdirSync(sandboxBase).sort();
+    }
+    catch {
+        return null;
+    }
+    let found = null;
+    for (const inv of invs) {
+        const candidate = path.join(sandboxBase, inv, genId, dirName, ".bench", "transcripts", `${unitId}.jsonl`);
+        if (existsSync(candidate))
+            found = candidate;
+    }
+    return found;
+}
+function maskMemberText(plan, text) {
+    return new TextEncoder().encode(plan.mask(text));
+}
+export async function exportBundle(req) {
+    const repo = req.entry.spec.repoPath;
+    const chosen = selectGens(candidateRowsByGenId(repo), req.select);
+    if (chosen.length === 0)
+        cannotAnswer("bundle export: the ledger holds no candidate generations yet", `abathur run --genome ${req.entry.spec.label} --mutator <template>`);
+    for (const gen of chosen) {
+        if (!PATH_SAFE.test(gen.genId)) {
+            blocked(`bundle export: ledger genId '${gen.genId}' is not path-safe for member names or the output filename`, "repair or quarantine the tampered ledger row before exporting");
+        }
+    }
+    const ids = chosen.map((c) => c.genId);
+    const primary = chosen.find((c) => c.genId === primaryGenId(ids));
+    if (primary === undefined)
+        blocked("bundle export: primary generation vanished mid-export");
+    const primaryRow = primary.data;
+    if (primaryRow.commitSha === undefined)
+        cannotAnswer(`bundle export: candidate row ${primary.genId} lacks commitSha`);
+    if (!COMMIT_RE.test(primaryRow.headCommit))
+        cannotAnswer(`bundle export: candidate row ${primary.genId} carries a non-commit parent '${primaryRow.headCommit}'`);
+    const trees = new Map();
+    for (const gen of chosen) {
+        if (gen.data.commitSha === undefined)
+            cannotAnswer(`bundle export: candidate row ${gen.genId} lacks commitSha`);
+        trees.set(gen.genId, await gitTree(repo, gen.genId, gen.data.commitSha));
+    }
+    const spec = containedSpec(trees.get(primary.genId) ?? new Map(), primary.genId);
+    const genomeFingerprint = fingerprint(spec);
+    const plan = maskPlanFor(spec, req.home);
+    const members = [];
+    for (const [genId, tree] of [...trees.entries()].sort((a, b) => (a[0] < b[0] ? -1 : 1))) {
+        for (const [rel, content] of [...tree.entries()].sort((a, b) => (a[0] < b[0] ? -1 : 1))) {
+            members.push({ path: `trees/${genId}/${rel}`, content });
+        }
+    }
+    const patchRun = await tryGit(["-C", repo, "diff", "--no-color", primaryRow.headCommit, primaryRow.commitSha]);
+    if (!patchRun.ok)
+        blocked(`bundle export: git diff ${primaryRow.headCommit}..${primaryRow.commitSha} failed: ${patchRun.error.stderr.split("\n")[0] ?? "git diff"}`);
+    members.push({ path: "patch.diff", content: maskMemberText(plan, patchRun.stdout) });
+    const lineage = {
+        primary: primary.genId,
+        gens: chosen.map((g) => lineageEntry(g.genId, g.data)),
+    };
+    members.push({ path: "lineage.json", content: maskMemberText(plan, `${JSON.stringify(lineage, null, 2)}\n`) });
+    const sandboxBase = path.join(req.configDir, "bench-sandboxes");
+    for (const gen of chosen) {
+        for (const unit of gen.data.units) {
+            if (unit.split !== "train")
+                continue; // val evidence is structurally excluded
+            for (const runId of unit.runIds) {
+                const rep = repOfRunId(runId, gen.genId, unit.unitId);
+                if (!PATH_SAFE.test(runId) || !PATH_SAFE.test(unit.unitId)) {
+                    blocked(`bundle export: runId '${runId}' is not path-safe for an evidence member name`);
+                }
+                const transcript = findTranscript(sandboxBase, gen.genId, `${unit.unitId}-${rep}`, unit.unitId);
+                if (transcript === null)
+                    continue;
+                const memberPath = `${EVIDENCE_PREFIX}${gen.genId}/${runId}.jsonl`;
+                const size = statSync(transcript).size;
+                if (size > EVIDENCE_CAP_BYTES) {
+                    blocked(`bundle export: ${memberPath} is ${String(size)} bytes — exceeds the 2 MiB/unit evidence cap; refusing (no truncation)`);
+                }
+                members.push({ path: memberPath, content: maskMemberText(plan, readFileSync(transcript, "utf8")) });
+            }
+        }
+    }
+    const readme = renderReadme({
+        label: spec.label,
+        genomeFingerprint,
+        genIds: ids.slice().sort(),
+        primary: lineageEntry(primary.genId, primaryRow),
+        memberCount: members.length,
+    });
+    members.push({ path: "README.md", content: maskMemberText(plan, readme) });
+    const files = [...members]
+        .sort((a, b) => (a.path < b.path ? -1 : 1))
+        .map((m) => ({ path: m.path, sha256: sha256Hex(m.content), len: m.content.length }));
+    const manifestBody = {
+        genome: { label: spec.label, fingerprint: genomeFingerprint },
+        parent: primaryRow.headCommit,
+        benchDigest: benchDigestFor(spec, trees.get(primary.genId) ?? new Map(), primary.genId),
+        benchProvenance: deriveBenchProvenance(primaryRow, spec),
+        budgetCounters: primaryRow.counters,
+        stats: { matrix: primaryRow.units, verdict: primaryRow.verdict ?? null },
+        sealedGlobs: spec.kernel.immutableGlobs,
+        files,
+        rationale: primaryRow.rationale ?? "",
+        frictionDigests: [],
+    };
+    const manifestDoc = { schema_version: BUNDLE_SCHEMA_VERSION, digest_algo: DIGEST_ALGO, ...manifestBody };
+    const manifestBytes = new TextEncoder().encode(plan.mask(`${JSON.stringify(manifestDoc, null, 2)}\n`));
+    const allMembers = [...members, { path: "manifest.json", content: manifestBytes }];
+    const leaks = [];
+    for (const m of [...allMembers].sort((a, b) => (a.path < b.path ? -1 : 1))) {
+        if (m.path.startsWith("trees/"))
+            continue; // git-object byte-truth, masked members carry the identifiers
+        const hit = scanMemberLeaks(new TextDecoder().decode(m.content), plan, req.home);
+        if (hit !== null)
+            leaks.push(`${m.path}:${String(hit.line)} — "${hit.snippet}"`);
+    }
+    if (leaks.length > 0) {
+        blocked(`bundle export: refusing to write — machine-local leak(s) detected pre-write:\n  - ${leaks.join("\n  - ")}`, "declare literals under the spec's bundle.maskLiterals or scrub the source data");
+    }
+    const name = `abathur-${genomeFingerprint.slice(0, 16)}-${ids.slice().sort().join("_")}.bundle.tgz`;
+    mkdirSync(req.outDir, { recursive: true });
+    const bundlePath = path.join(req.outDir, name);
+    const { gzipSync } = await import("node:zlib");
+    const tmpPath = path.join(req.outDir, `.${name}.partial-${String(process.pid)}`);
+    writeFileSync(tmpPath, new Uint8Array(gzipSync(writeTar(allMembers))));
+    renameSync(tmpPath, bundlePath);
+    return {
+        bundlePath,
+        lines: [
+            `bundle export: ${bundlePath}`,
+            `  genome ${spec.label} fingerprint ${genomeFingerprint.slice(0, 16)}…, gens: ${ids.slice().sort().join(", ")}`,
+            `  ${String(allMembers.length)} members, patch ${primaryRow.headCommit.slice(0, 8)}..${primaryRow.commitSha.slice(0, 8)}, benchDigest ${manifestBody.benchDigest.slice(0, 16)}…`,
+        ],
+    };
+}

package/dist/core/bundle-inspect.js

@@ -0,0 +1,143 @@
+// `abathur bundle inspect` (todo 12): treat the bundle as UNTRUSTED input. Never
+// trusts manifest sha values blindly — every pinned member is re-hashed from the
+// extracted bytes; the genome fingerprint and benchDigest are recomputed from the
+// contained tree; the whole non-tree bundle is re-scanned for machine leaks with
+// this machine's HOME/repoPath added; val-derived evidence members are rejected.
+// Malformed container/manifest/digest_algo ⇒ exit 2 (cannot-answer); integrity
+// failures ⇒ exit 1 naming path + expected/actual values or member:line.
+import { existsSync, readFileSync } from "node:fs";
+import { gunzipSync } from "node:zlib";
+import { blocked, cannotAnswer, EXIT_OK } from "../exit.js";
+import { fingerprint } from "./ids.js";
+import { benchDigestFor, bundleGenIds, containedSpec, EVIDENCE_PREFIX, maskPlanFor, primaryGenId, treeOf, sha256Hex, } from "./bundle-common.js";
+import { bundleManifestSchema, DIGEST_ALGO } from "./bundle-manifest.js";
+import { scanMemberLeaks } from "./bundle-mask.js";
+import { readTar } from "./bundle-tar.js";
+function loadMembers(bundlePath) {
+    if (!existsSync(bundlePath))
+        cannotAnswer(`bundle inspect: cannot read ${bundlePath}`);
+    let tarBytes;
+    try {
+        tarBytes = new Uint8Array(gunzipSync(readFileSync(bundlePath)));
+    }
+    catch (cause) {
+        return cannotAnswer(`bundle inspect: ${bundlePath} is not a gzip stream: ${cause instanceof Error ? cause.message.split("\n")[0] : String(cause)}`);
+    }
+    try {
+        return readTar(tarBytes);
+    }
+    catch (cause) {
+        return cannotAnswer(`bundle inspect: ${bundlePath} is not a readable tar: ${cause instanceof Error ? cause.message : String(cause)}`);
+    }
+}
+function parseManifest(members) {
+    const raw = members.find((m) => m.path === "manifest.json");
+    if (raw === undefined)
+        cannotAnswer("bundle inspect: manifest.json missing from bundle");
+    let document;
+    try {
+        document = JSON.parse(new TextDecoder().decode(raw.content));
+    }
+    catch (cause) {
+        return cannotAnswer(`bundle inspect: manifest.json is not valid JSON: ${cause instanceof Error ? cause.message.split("\n")[0] : String(cause)}`);
+    }
+    const parsed = bundleManifestSchema.safeParse(document);
+    if (!parsed.success) {
+        cannotAnswer(`bundle inspect: manifest.json failed schema v1: ${parsed.error.issues.map((i) => `${String(i.path.join("."))}: ${i.message}`).join("; ")}`);
+    }
+    return parsed.data;
+}
+function verifyPinnedMembers(members, manifest) {
+    const byPath = new Map(members.map((m) => [m.path, m]));
+    const pinned = new Set();
+    for (const f of manifest.files) {
+        if (f.path === "manifest.json")
+            blocked("bundle inspect: manifest.json must not pin itself in files[]");
+        pinned.add(f.path);
+        const member = byPath.get(f.path);
+        if (member === undefined)
+            blocked(`bundle inspect: pinned member '${f.path}' is missing from the bundle`);
+        const actualSha = sha256Hex(member.content);
+        if (actualSha !== f.sha256)
+            blocked(`bundle inspect: ${f.path}: sha256 mismatch — expected ${f.sha256} actual ${actualSha}`);
+        if (member.content.length !== f.len)
+            blocked(`bundle inspect: ${f.path}: length mismatch — expected ${String(f.len)} actual ${String(member.content.length)}`);
+    }
+    for (const m of members) {
+        if (m.path === "manifest.json")
+            continue;
+        if (!pinned.has(m.path))
+            blocked(`bundle inspect: unexpected member '${m.path}' is not pinned in manifest.files`);
+    }
+}
+function verifyGenomes(members, manifest) {
+    const genIds = bundleGenIds(members);
+    if (genIds.length === 0)
+        cannotAnswer("bundle inspect: bundle ships no trees/<genId>/ generation content");
+    for (const genId of genIds) {
+        const spec = containedSpec(treeOf(members, genId), genId);
+        const recomputed = fingerprint(spec);
+        if (recomputed !== manifest.genome.fingerprint) {
+            blocked(`bundle inspect: genome fingerprint mismatch — trees/${genId}/genome.jsonc fingerprints to ${recomputed}, manifest claims ${manifest.genome.fingerprint}`, "wrong-genome import attempt: the contained spec does not match the bundle's claimed genome");
+        }
+        if (spec.label !== manifest.genome.label) {
+            blocked(`bundle inspect: genome label mismatch in trees/${genId}/ — spec says '${spec.label}', manifest claims '${manifest.genome.label}'`);
+        }
+    }
+    return primaryGenId(genIds);
+}
+function verifyBenchDigest(members, manifest, primary) {
+    const tree = treeOf(members, primary);
+    const spec = containedSpec(tree, primary);
+    const recomputed = benchDigestFor(spec, tree, primary);
+    if (recomputed !== manifest.benchDigest) {
+        blocked(`bundle inspect: benchDigest mismatch — contained tree recomputes to ${recomputed}, manifest claims ${manifest.benchDigest}`);
+    }
+}
+function verifyValExclusion(members, primary) {
+    const spec = containedSpec(treeOf(members, primary), primary);
+    const valIds = spec.bench.units.filter((u) => u.split === "val").map((u) => u.id);
+    const evidenceNames = members.filter((m) => m.path.startsWith(EVIDENCE_PREFIX)).map((m) => m.path.slice(m.path.lastIndexOf("/") + 1));
+    for (const valId of valIds) {
+        const escaped = valId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const marker = new RegExp(`-${escaped}-\\d+\\.jsonl$`);
+        const hit = evidenceNames.find((n) => marker.test(n));
+        if (hit !== undefined)
+            blocked(`bundle inspect: evidence member '${hit}' derives from VAL unit '${valId}' — bundles carry train evidence only`);
+    }
+}
+function verifyMask(members, home) {
+    const plans = bundleGenIds(members).map((genId) => maskPlanFor(containedSpec(treeOf(members, genId), genId), home));
+    for (const m of [...members].sort((a, b) => (a.path < b.path ? -1 : 1))) {
+        if (m.path.startsWith("trees/"))
+            continue;
+        const text = new TextDecoder().decode(m.content);
+        for (const plan of plans) {
+            const hit = scanMemberLeaks(text, plan, home);
+            if (hit !== null)
+                blocked(`bundle inspect: leak in ${m.path}:${String(hit.line)} — "${hit.snippet}" (declared literals and machine-absolute paths must never survive in a bundle)`);
+        }
+    }
+}
+export function inspectBundle(req) {
+    const members = loadMembers(req.bundlePath);
+    const manifest = parseManifest(members);
+    if (manifest.digest_algo !== DIGEST_ALGO) {
+        cannotAnswer(`bundle inspect: unknown digest_algo '${manifest.digest_algo}' — this build understands '${DIGEST_ALGO}' only`);
+    }
+    verifyPinnedMembers(members, manifest);
+    if (!members.some((m) => m.path === "patch.diff"))
+        blocked("bundle inspect: patch.diff missing from bundle");
+    const primary = verifyGenomes(members, manifest);
+    verifyBenchDigest(members, manifest, primary);
+    verifyValExclusion(members, primary);
+    verifyMask(members, req.home);
+    return {
+        exitCode: EXIT_OK,
+        lines: [
+            `bundle inspect: OK — ${manifest.genome.label} fingerprint ${manifest.genome.fingerprint.slice(0, 16)}…`,
+            `  gens: ${bundleGenIds(members).join(", ")} (primary ${primary}, parent ${manifest.parent.slice(0, 8)}…)`,
+            `  ${String(manifest.files.length + 1)} members re-hashed, benchDigest + mask scan re-verified, verdict: ${manifest.stats.verdict ?? "n/a"}`,
+        ],
+    };
+}

package/dist/core/bundle-manifest.js

@@ -0,0 +1,105 @@
+// Bundle manifest v1 — exact plan schema (todo 12, line 166). Key insertion
+// order below IS the serialized byte order: re-exports must stay byte-identical,
+// and tests pin the field list verbatim.
+import { z } from "zod";
+import { ADAPTER_IFACE_VERSION, fingerprint } from "./ids.js";
+import { unitMatrixRowSchema } from "./evolve/run-rows.js";
+export const DIGEST_ALGO = "sha256-canonical-v1";
+export const BUNDLE_SCHEMA_VERSION = 1;
+const nullable = (inner) => z.union([inner, z.null()]);
+export const bundleManifestSchema = z.strictObject({
+    schema_version: z.literal(BUNDLE_SCHEMA_VERSION),
+    digest_algo: z.string(),
+    genome: z.strictObject({
+        label: z.string().min(1),
+        fingerprint: z.string().regex(/^[0-9a-f]{64}$/, "genome.fingerprint must be sha256 hex"),
+    }),
+    parent: z.string().regex(/^[0-9a-f]{7,64}$/, "parent must be a git commit id"),
+    benchDigest: z.string().regex(/^[0-9a-f]{64}$/),
+    benchProvenance: z.strictObject({
+        opencodeVersion: nullable(z.string()),
+        agentModel: nullable(z.string()),
+        adapterConfigDigest: nullable(z.string()),
+        fixtureSeedId: nullable(z.string()),
+        judgeModel: nullable(z.string()),
+        mutatorModel: nullable(z.string()),
+        nRepeats: nullable(z.number().int().nonnegative()),
+        statsConfigDigest: nullable(z.string()),
+    }),
+    budgetCounters: z.strictObject({
+        candidates: z.number(),
+        modelCalls: z.number(),
+        tokens: z.number(),
+        wallS: z.number(),
+    }),
+    stats: z.strictObject({
+        matrix: z.array(unitMatrixRowSchema),
+        verdict: nullable(z.enum(["nominated", "culled", "indeterminate", "inconclusive"])),
+    }),
+    sealedGlobs: z.array(z.string()),
+    files: z.array(z.strictObject({
+        path: z.string().min(1),
+        sha256: z.string().regex(/^[0-9a-f]{64}$/),
+        len: z.number().int().nonnegative(),
+    })).min(1),
+    rationale: z.string(),
+    frictionDigests: z.array(z.string()),
+});
+/** Ledger row + contained spec → the plan's benchProvenance field set. Fields the
+ *  bench kind genuinely does not have (toy has no opencode version; mutator model
+ *  lands with todo 11) are explicit nulls, never guesses. */
+export function deriveBenchProvenance(row, spec) {
+    const bench = spec.bench;
+    return {
+        opencodeVersion: row.benchProvenance.versions.find((v) => v.bin === "opencode")?.version ?? null,
+        agentModel: bench.agentModel ?? null,
+        adapterConfigDigest: fingerprint({
+            adapterIface: ADAPTER_IFACE_VERSION,
+            benchType: bench.type,
+            graderCommand: bench.graderCommand,
+            judgeCommand: bench.judgeCommand ?? null,
+            resetCommand: bench.resetCommand ?? null,
+            runCommand: bench.runCommand,
+            seedCommand: bench.seedCommand ?? null,
+            timeoutS: bench.timeoutS,
+        }),
+        fixtureSeedId: bench.seedCommand === undefined ? null : fingerprint({ seedCommand: bench.seedCommand }),
+        judgeModel: bench.judgeModel ?? null,
+        mutatorModel: null,
+        nRepeats: row.reps,
+        statsConfigDigest: fingerprint(bench.stats),
+    };
+}
+export function lineageEntry(genId, row) {
+    return {
+        genId,
+        parent: row.headCommit,
+        commitSha: row.commitSha ?? "",
+        treeSha: row.treeSha ?? "",
+        verdict: row.verdict ?? null,
+        rationale: row.rationale ?? "",
+    };
+}
+export function renderReadme(params) {
+    const lines = [
+        `# abathur lineage bundle — ${params.label}`,
+        "",
+        `- genome fingerprint: \`${params.genomeFingerprint}\``,
+        `- generations (newest primary last): ${params.genIds.map((g) => `\`${g}\``).join(", ")}`,
+        `- primary parent commit: \`${params.primary.parent}\``,
+        `- primary commit: \`${params.primary.commitSha}\` (tree \`${params.primary.treeSha}\`)`,
+        `- verdict: ${params.primary.verdict ?? "n/a"}`,
+        `- rationale: ${params.primary.rationale}`,
+        "",
+        "Members: manifest.json (schema v1, digest sha256-canonical-v1), patch.diff",
+        "(primary parent..commit), lineage.json (ledger-row summaries), trees/<genId>/",
+        "(generation content read from git objects at export), README.md, and",
+        "evidence/<genId>/<runId>.jsonl — REDACTED train-only bench transcripts",
+        "(val units are structurally never exported). Machine-local paths and any",
+        "declared mask literals appear only as <HOME>/<GENOME>/<MASKED-n> placeholders.",
+        "This bundle carries no signatures and implies no trust — verify with",
+        "`abathur bundle inspect <this file>`, which re-hashes every pinned member.",
+        "",
+    ];
+    return lines.join("\n");
+}

package/dist/core/bundle-mask.js

@@ -0,0 +1,75 @@
+// Machine-identifier masking + whole-member leak scanning for lineage bundles
+// (todo 12, oracle Major #7 + round-2 #4). Export masks every non-tree member at
+// build; the PRE-WRITE scan over the final serialized bytes is the hard gate —
+// a surviving declared literal or any generic machine-rooted absolute path
+// (fail-closed, catches undeclared secrets like a wiki mount point) names the
+// member + 1-based line and blocks the write.
+/** Machine-rooted absolute-path roots; anything of the form /<root>/... surviving
+ *  a masked member is treated as a leak even when it was never declared. */
+const MACHINE_PATH_ROOTS = "home|root|Users|tmp|var|opt|etc|usr|srv|mnt|media|private|proc|sys";
+const MACHINE_PATH_RE = new RegExp(`(?:^|[\\s"'\\\`(<=[{,:])\\/(?:${MACHINE_PATH_ROOTS})\\/`, "m");
+function dedupeLiterals(entries) {
+    const byLength = [...new Map(entries.map((e) => [e.literal, e])).values()].sort((a, b) => b.literal.length - a.literal.length);
+    return byLength;
+}
+export function buildMaskPlan(input) {
+    const entries = [];
+    if (input.home !== null && input.home.length > 0)
+        entries.push({ literal: input.home, placeholder: "<HOME>" });
+    entries.push({ literal: input.repoPath, placeholder: "<GENOME>" });
+    input.extra.forEach((literal, i) => {
+        entries.push({ literal, placeholder: `<MASKED-${String(i + 1)}>` });
+    });
+    const literals = dedupeLiterals(entries);
+    return {
+        literals,
+        mask(text) {
+            let out = text;
+            for (const { literal, placeholder } of literals)
+                out = out.split(literal).join(placeholder);
+            return out;
+        },
+    };
+}
+function firstLineOf(text, index) {
+    const before = text.slice(0, index);
+    const nl = before.lastIndexOf("\n");
+    const lineStart = nl + 1;
+    let lineEnd = text.indexOf("\n", lineStart);
+    if (lineEnd === -1)
+        lineEnd = text.length;
+    const raw = text.slice(lineStart, lineEnd).replace(/[^\x20-\x7e]/g, " ").trim();
+    return {
+        line: before.split("\n").length,
+        snippet: raw.length > 120 ? `${raw.slice(0, 117)}...` : raw,
+    };
+}
+/**
+ * Scan one final serialized member body for leaks. `extraLiterals` lets inspect
+ * add this machine's HOME/repoPath to the check even when the exporting machine
+ * declared different maskLiterals. Returns the first hit (member scope), or null.
+ */
+export function scanMemberLeaks(text, plan, ...extraLiterals) {
+    const candidates = [
+        ...plan.literals,
+        ...extraLiterals
+            .filter((l) => l !== null && l.length > 0)
+            .map((literal) => ({ literal, placeholder: "?" })),
+    ];
+    let best = null;
+    for (const { literal } of candidates) {
+        const at = text.indexOf(literal);
+        if (at === -1)
+            continue;
+        if (best === null || at < best.at)
+            best = { literal, ...firstLineOf(text, at), at };
+    }
+    const machine = MACHINE_PATH_RE.exec(text);
+    if (machine !== null) {
+        const at = machine.index + (machine[0].startsWith("/") ? 0 : 1);
+        const label = `absolute machine path ${machine[0].slice(machine[0].startsWith("/") ? 0 : 1)}`;
+        if (best === null || at < best.at)
+            best = { literal: label, ...firstLineOf(text, at), at };
+    }
+    return best;
+}