@rotifer/playground 0.26.3 → 0.28.0

package/dist/commands/genome-import.js

@@ -0,0 +1,632 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genomeImportCommand = exports.GenomeImportError = exports.DEFAULT_MAX_EVAL_AGE_DAYS = exports.DEFAULT_MIN_VG = void 0;
+exports.compositionPlan = compositionPlan;
+exports.parseBlueprint = parseBlueprint;
+exports.locatePinned = locatePinned;
+exports.effectiveMinVg = effectiveMinVg;
+exports.resolveRole = resolveRole;
+exports.importGenome = importGenome;
+exports.runGenomeImport = runGenomeImport;
+const commander_1 = require("commander");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const promises_1 = require("node:readline/promises");
+const display = __importStar(require("../utils/display.js"));
+const config_js_1 = require("../utils/config.js");
+const project_root_js_1 = require("../utils/project-root.js");
+const binding_js_1 = require("../utils/binding.js");
+const validate_gene_name_js_1 = require("../utils/validate-gene-name.js");
+const client_js_1 = require("../cloud/client.js");
+const capability_candidates_js_1 = require("../cloud/capability-candidates.js");
+const install_js_1 = require("./install.js");
+const agent_create_js_1 = require("./agent-create.js");
+const genome_js_1 = require("./genome.js");
+/** Recommended V_min of §5.1: the floor every capability selection must clear. */
+exports.DEFAULT_MIN_VG = 0.7;
+exports.DEFAULT_MAX_EVAL_AGE_DAYS = 90;
+const PAR_MERGES = new Set(["first", "concat", "merge"]);
+class GenomeImportError extends Error {
+    hint;
+    constructor(message, hint) {
+        super(message);
+        this.hint = hint;
+        this.name = "GenomeImportError";
+    }
+}
+exports.GenomeImportError = GenomeImportError;
+const OPS_FROM_SPEC = Object.fromEntries(Object.entries(genome_js_1.COMPARE_OPS).map(([local, spec]) => [spec, local]));
+function outsideSubset(why) {
+    return new GenomeImportError(`Composition is outside the v0.9.2 executable subset: ${why}`, "v0.9.2 imports Gene, Seq of genes, Par of genes (no deadline), and Cond/TryCatch over exactly two genes.");
+}
+function isObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/** The single key of an externally tagged AlgebraExpr, and its body. */
+function tagOf(expr) {
+    if (!isObject(expr))
+        throw outsideSubset("an expression is not an object");
+    const keys = Object.keys(expr);
+    if (keys.length !== 1)
+        throw outsideSubset(`an expression has ${keys.length} tags`);
+    const body = expr[keys[0]];
+    if (!isObject(body))
+        throw outsideSubset(`'${keys[0]}' has no body`);
+    return [keys[0], body];
+}
+/** A `Gene` leaf's role, checked against the snapshot's gene list. */
+function leafRole(expr, genes) {
+    const [tag, body] = tagOf(expr);
+    if (tag === "RemoteGene")
+        throw outsideSubset("RemoteGene is not supported");
+    if (tag !== "Gene")
+        throw outsideSubset(`'${tag}' appears where only a single gene may`);
+    const ref = body.geneRef;
+    if (!isObject(ref) || typeof ref.role !== "string" || typeof ref.geneId !== "string") {
+        throw outsideSubset("a Gene leaf has no geneRef { geneId, role }");
+    }
+    const listed = genes.find((g) => g.role === ref.role);
+    if (!listed || listed.geneId !== ref.geneId) {
+        throw new GenomeImportError(`Composition leaf '${ref.role}' does not match snapshot.genes`);
+    }
+    return ref.role;
+}
+function compositionPlan(blueprint) {
+    const genes = blueprint.snapshot.genes;
+    const order = genes.map((g) => g.role);
+    const ext = blueprint.bindingExtensions?.[genome_js_1.BINDING_NAME] ?? {};
+    const expr = blueprint.snapshot.composition;
+    // §4.3: a genome is an ordered composition; with no expression it runs in order.
+    if (expr === undefined) {
+        return genes.length === 1 ? { type: "Single", roles: order } : { type: "Seq", roles: order };
+    }
+    const [tag, body] = tagOf(expr);
+    let plan;
+    switch (tag) {
+        case "Gene":
+            plan = { type: "Single", roles: [leafRole(expr, genes)] };
+            break;
+        case "Seq": {
+            if (!Array.isArray(body.steps) || body.steps.length === 0)
+                throw outsideSubset("Seq has no steps");
+            plan = { type: "Seq", roles: body.steps.map((s) => leafRole(s, genes)) };
+            break;
+        }
+        case "Par": {
+            // `agent run` executes Par flat and n-ary; export writes it right-nested.
+            // Flatten Par(a, Par(b, c)) back to [a, b, c]; anything else nested is refused.
+            const roles = [];
+            let node = body;
+            for (;;) {
+                if (node.deadline !== undefined && node.deadline !== null)
+                    throw outsideSubset("Par with a deadline");
+                roles.push(leafRole(node.left, genes));
+                const [rightTag, rightBody] = tagOf(node.right);
+                if (rightTag === "Par") {
+                    node = rightBody;
+                    continue;
+                }
+                roles.push(leafRole(node.right, genes));
+                break;
+            }
+            const merge = ext.parMerge ?? "first";
+            if (typeof merge !== "string" || !PAR_MERGES.has(merge)) {
+                throw new GenomeImportError(`bindingExtensions["${genome_js_1.BINDING_NAME}"].parMerge '${String(merge)}' is not first, concat or merge`);
+            }
+            plan = { type: "Par", roles, parMerge: merge };
+            break;
+        }
+        case "Cond": {
+            const p = body.predicate;
+            if (!isObject(p) || typeof p.field !== "string" || typeof p.operator !== "string" || !("value" in p)) {
+                throw outsideSubset("Cond predicate must be { field, operator, value }");
+            }
+            // agent run substitutes "type" for an empty field and "primary" for a null
+            // value; accepting them would run a different branch than the one declared.
+            if (p.field === "")
+                throw outsideSubset("Cond predicate needs a non-empty field");
+            if (p.value === null)
+                throw outsideSubset("Cond predicate value must not be null");
+            const op = OPS_FROM_SPEC[p.operator];
+            if (!op)
+                throw outsideSubset(`unknown CompareOp '${p.operator}'`);
+            plan = {
+                type: "Cond",
+                roles: [leafRole(body.ifTrue, genes), leafRole(body.ifFalse, genes)],
+                predicate: { field: p.field, op, value: p.value },
+            };
+            break;
+        }
+        case "TryCatch":
+            plan = { type: "Try", roles: [leafRole(body.body, genes), leafRole(body.handler, genes)] };
+            break;
+        default:
+            throw outsideSubset(`'${tag}' is not a §15.2 operator v0.9.2 supports`);
+    }
+    if (plan.roles.join("\u0000") !== order.join("\u0000")) {
+        throw outsideSubset("the composition must use every gene of snapshot.genes once, in order");
+    }
+    return plan;
+}
+function checkMinVg(value, where) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < genome_js_1.MIN_VG_FLOOR || value >= 1) {
+        throw new GenomeImportError(`${where} must be in [${genome_js_1.MIN_VG_FLOOR}, 1.0)`, "§5.1 does not allow a V(g) threshold below 0.5.");
+    }
+    return value;
+}
+/** Parse a Blueprint, keep only what v0.9.2 can rebuild faithfully, and run the credential scan. */
+function parseBlueprint(text) {
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch (err) {
+        // The parser's own message quotes the input around the error, which may be
+        // a key; report only where it broke.
+        const position = /position (\d+)/.exec(err.message)?.[1];
+        throw new GenomeImportError(`Not a JSON Blueprint: the file is not valid JSON${position ? ` (at position ${position})` : ""}`);
+    }
+    if (!isObject(raw))
+        throw new GenomeImportError("Not a Blueprint: the top level is not an object");
+    // The credential scan runs before any structural check: structural errors
+    // name roles, keys and values from the file, and none of those may be a
+    // secret by the time they are printed. Findings carry masked pointers only.
+    const findings = (0, genome_js_1.scanBlueprint)(raw, { isLeafIdCheckedStructurally: true });
+    if (findings.length > 0) {
+        const where = findings.map((f) => `${f.pointer || "/"} [${f.layer}] ${f.rule}`).join("; ");
+        throw new GenomeImportError(`The Blueprint carries what looks like a credential, so it is not imported: ${where}`);
+    }
+    const format = raw.blueprintFormat;
+    if (typeof format !== "number" || !Number.isInteger(format) || format < 1) {
+        throw new GenomeImportError("Not a Blueprint: blueprintFormat is missing or not a positive integer");
+    }
+    if (format > genome_js_1.BLUEPRINT_FORMAT) {
+        throw new GenomeImportError(`Blueprint format ${format} is newer than this CLI understands (${genome_js_1.BLUEPRINT_FORMAT})`, "Update the CLI: rotifer self-update");
+    }
+    const snapshot = raw.snapshot;
+    if (!isObject(snapshot) || !Array.isArray(snapshot.genes) || snapshot.genes.length === 0) {
+        throw new GenomeImportError("Blueprint has no snapshot.genes");
+    }
+    const roles = new Set();
+    for (const g of snapshot.genes) {
+        if (!isObject(g) || typeof g.geneId !== "string" || typeof g.role !== "string" || g.role === "") {
+            throw new GenomeImportError("Every snapshot.genes entry needs a geneId and a role");
+        }
+        if (!genome_js_1.GENE_ID_V2.test(g.geneId))
+            throw new GenomeImportError(`Gene '${g.role}' has no v2 gene ID`);
+        if (g.optional === true)
+            throw outsideSubset(`gene '${g.role}' is optional, which agent run has no notion of`);
+        if (roles.has(g.role))
+            throw new GenomeImportError(`Role '${g.role}' appears twice in snapshot.genes`);
+        roles.add(g.role);
+    }
+    if (raw.capabilities !== undefined) {
+        if (!isObject(raw.capabilities))
+            throw new GenomeImportError("capabilities must be an object");
+        for (const [role, q] of Object.entries(raw.capabilities)) {
+            if (!roles.has(role))
+                throw new GenomeImportError(`capabilities has a role '${role}' that snapshot.genes lacks`);
+            if (!isObject(q) || typeof q.domain !== "string" || q.domain === "") {
+                throw new GenomeImportError(`capabilities['${role}'] has no domain`);
+            }
+            if (q.minFitness !== undefined && (typeof q.minFitness !== "number" || q.minFitness < 0 || q.minFitness > 1)) {
+                throw new GenomeImportError(`capabilities['${role}'].minFitness must be between 0 and 1`);
+            }
+            if (q.excludeGeneIds !== undefined) {
+                if (!Array.isArray(q.excludeGeneIds) || !q.excludeGeneIds.every((id) => typeof id === "string" && genome_js_1.GENE_ID_V2.test(id))) {
+                    throw new GenomeImportError(`capabilities['${role}'].excludeGeneIds must be v2 gene IDs`);
+                }
+            }
+        }
+    }
+    if (raw.resolutionHints !== undefined) {
+        if (!isObject(raw.resolutionHints))
+            throw new GenomeImportError("resolutionHints must be an object");
+        for (const [role, h] of Object.entries(raw.resolutionHints)) {
+            if (!roles.has(role))
+                throw new GenomeImportError(`resolutionHints has a role '${role}' that snapshot.genes lacks`);
+            const isValid = isObject(h) &&
+                ["owner", "name", "version", "fidelity"].every((k) => typeof h[k] === "string" && h[k] !== "") &&
+                (h.cloudId === undefined || typeof h.cloudId === "string");
+            if (!isValid)
+                throw new GenomeImportError(`resolutionHints['${role}'] needs owner, name, version and fidelity`);
+        }
+    }
+    const blueprint = raw;
+    const ext = blueprint.bindingExtensions?.[genome_js_1.BINDING_NAME];
+    const suggestedMinVg = ext?.minVg === undefined ? undefined : checkMinVg(ext.minVg, `bindingExtensions["${genome_js_1.BINDING_NAME}"].minVg`);
+    const plan = compositionPlan(blueprint);
+    return { blueprint, plan, suggestedMinVg };
+}
+function isWrapped(fidelity) {
+    return fidelity.toLowerCase() === "wrapped";
+}
+/** Lock mode: the exact author + name + version from the hints. */
+async function locatePinned(role, hint) {
+    if (!hint) {
+        throw new GenomeImportError(`Role '${role}' has no resolutionHints, so it cannot be located by gene ID`, "The author's gene was never published; ask them to publish it, or import with capability mode.");
+    }
+    if (isWrapped(hint.fidelity)) {
+        throw new GenomeImportError(`Role '${role}' is a Wrapped gene: v0.9.2 does not support installing Wrapped genes from the Registry`, "Drop --pinned so capability mode can look for a Native/Hybrid substitute.");
+    }
+    const same = (a, b) => a.toLowerCase() === b.toLowerCase();
+    if (hint.cloudId) {
+        try {
+            const row = await (0, client_js_1.getGene)(hint.cloudId);
+            if (same(row.owner, hint.owner) && row.name === hint.name && row.version === hint.version) {
+                return { cloudId: row.id };
+            }
+        }
+        catch {
+            // Unpublished or unknown id: fall through to the version list.
+        }
+    }
+    const versions = await (0, client_js_1.listGeneVersions)(hint.owner, hint.name);
+    const match = versions.find((v) => v.version === hint.version);
+    if (!match) {
+        throw new GenomeImportError(`Role '${role}': ${hint.owner}/${hint.name}@${hint.version} is not in the Registry (unpublished, or never published)`);
+    }
+    return { cloudId: match.id };
+}
+/** Strictest of the author's suggestion, the local flag, and the §5.1 default. */
+function effectiveMinVg(suggested, local) {
+    return Math.max(exports.DEFAULT_MIN_VG, suggested ?? 0, local ?? 0);
+}
+async function resolveRole(role, ctx) {
+    const { blueprint, options } = ctx;
+    const ref = blueprint.snapshot.genes.find((g) => g.role === role);
+    const hint = blueprint.resolutionHints?.[role];
+    const query = blueprint.capabilities?.[role];
+    const pinned = async (mode, extra = {}) => {
+        const { cloudId } = await locatePinned(role, hint);
+        return {
+            role,
+            mode,
+            originalGeneId: ref.geneId,
+            cloudId,
+            owner: hint.owner,
+            name: hint.name,
+            version: hint.version,
+            fidelity: hint.fidelity,
+            selfHealUpgrade: false,
+            crossAuthor: false,
+            ...extra,
+        };
+    };
+    if (options.isPinned || !query)
+        return pinned("pinned");
+    const policy = {
+        minFitness: query.minFitness ?? genome_js_1.DEFAULT_MIN_FITNESS,
+        minVg: effectiveMinVg(ctx.suggestedMinVg, options.minVg),
+        maxEvalAgeDays: options.maxEvalAgeDays ?? exports.DEFAULT_MAX_EVAL_AGE_DAYS,
+        now: options.now ?? new Date(),
+    };
+    const { candidates, admitted } = await (0, capability_candidates_js_1.resolveCapabilityCandidates)(query, policy);
+    if (admitted.length === 0) {
+        return pinned("fallback", { fallback: "no-admissible-candidate", candidates });
+    }
+    const best = admitted[0];
+    // With no hint there is no original author to compare against, so any pick is treated as a substitution.
+    const isCrossAuthor = !hint || best.owner.toLowerCase() !== hint.owner.toLowerCase();
+    if (isCrossAuthor && !options.isConfirmed) {
+        const question = `Role '${role}': replace ${hint ? `${hint.owner}/${hint.name}@${hint.version}` : "the original gene"} with ${best.owner}/${best.name}@${best.version} (another author)?`;
+        const isAccepted = options.confirm ? await options.confirm(question) : false;
+        if (!isAccepted) {
+            return pinned("fallback", {
+                fallback: "cross-author-not-confirmed",
+                candidates,
+                rejectedSubstitutions: [
+                    {
+                        cloudId: best.cloudId,
+                        owner: best.owner,
+                        name: best.name,
+                        version: best.version,
+                        reason: options.confirm ? "declined" : "cross-author substitute needs confirmation; re-run with --yes to accept",
+                    },
+                ],
+            });
+        }
+    }
+    return {
+        role,
+        mode: "capability",
+        originalGeneId: ref.geneId,
+        cloudId: best.cloudId,
+        owner: best.owner,
+        name: best.name,
+        version: best.version,
+        fidelity: best.fidelity,
+        ...(best.geneId ? { candidateGeneId: best.geneId } : {}),
+        selfHealUpgrade: !!hint && !isCrossAuthor && best.name === hint.name && best.version !== hint.version,
+        crossAuthor: isCrossAuthor,
+        evidence: best.evidence,
+        candidates,
+    };
+}
+/**
+ * Install every role into a staging directory, recompute each v2 gene ID, and
+ * check it: lock-mode roles must reproduce the Blueprint's geneId exactly;
+ * capability picks must be the content that was admitted. Nothing touches genes/ until every
+ * role has passed.
+ */
+async function installAndVerify(resolutions, genesRoot, stagingRoot, isVerbose) {
+    const staged = [];
+    for (const r of resolutions) {
+        (0, validate_gene_name_js_1.validateGeneName)(r.name);
+        const local = (0, node_path_1.join)(genesRoot, r.name);
+        const isLockMode = r.mode !== "capability";
+        if (isLockMode && (0, node_fs_1.existsSync)((0, node_path_1.join)(local, "phenotype.json"))) {
+            const localId = (0, binding_js_1.geneIdV2)(genesRoot, r.name);
+            if ("id" in localId && localId.id === r.originalGeneId) {
+                staged.push({ role: r.role, name: r.name, geneId: localId.id, stagedDir: null, contentHashCheck: null });
+                continue;
+            }
+        }
+        if (isVerbose)
+            display.info(`Installing ${r.owner}/${r.name}@${r.version} (${r.cloudId})`);
+        const { gene, contentHashCheck } = await (0, install_js_1.installGeneFromCloud)(r.cloudId, { genesDir: stagingRoot });
+        const hashWarning = (0, install_js_1.contentHashWarning)(gene.name, contentHashCheck);
+        if (hashWarning && isVerbose)
+            display.warn(hashWarning);
+        if (gene.name !== r.name) {
+            throw new GenomeImportError(`Registry row ${r.cloudId} is '${gene.name}', expected '${r.name}'`);
+        }
+        const id = (0, binding_js_1.geneIdV2)(stagingRoot, gene.name);
+        if (!("id" in id)) {
+            throw new GenomeImportError(`Installed '${gene.name}' has no v2 gene ID: ${id.reason}`);
+        }
+        if (isLockMode && id.id !== r.originalGeneId) {
+            throw new GenomeImportError(`geneId mismatch for role '${r.role}': the Blueprint pins ${r.originalGeneId}, ` +
+                `the installed ${r.owner}/${r.name}@${r.version} is ${id.id}`, "The gene's content differs from what the Blueprint was made from; nothing was imported.");
+        }
+        // Exclusion was applied at admission; what was installed must be what was admitted.
+        if (!isLockMode && id.id !== r.candidateGeneId) {
+            throw new GenomeImportError(`Role '${r.role}': installed ${r.owner}/${r.name}@${r.version} is ${id.id}, not the ${r.candidateGeneId} admitted`, "The Registry row changed between admission and install; nothing was imported.");
+        }
+        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(local, "phenotype.json"))) {
+            const localId = (0, binding_js_1.geneIdV2)(genesRoot, r.name);
+            if (!("id" in localId) || localId.id !== id.id) {
+                throw new GenomeImportError(`A different gene named '${r.name}' already exists in this workspace`, "Import into another workspace, or move the local gene aside first.");
+            }
+            staged.push({ role: r.role, name: r.name, geneId: id.id, stagedDir: null, contentHashCheck });
+            continue;
+        }
+        staged.push({ role: r.role, name: r.name, geneId: id.id, stagedDir: (0, node_path_1.join)(stagingRoot, gene.name), contentHashCheck });
+    }
+    return staged;
+}
+/** sha256 of the composition-relevant part of the Blueprint: same genome, same id. */
+function genomeIdOf(blueprint) {
+    const material = JSON.stringify({ genes: blueprint.snapshot.genes, composition: blueprint.snapshot.composition ?? null });
+    return (0, node_crypto_1.createHash)("sha256").update(material).digest("hex");
+}
+async function importGenome(file, options, ctx) {
+    if (options.minVg !== undefined)
+        checkMinVg(options.minVg, "--min-vg");
+    if (options.maxEvalAgeDays !== undefined && !(Number.isFinite(options.maxEvalAgeDays) && options.maxEvalAgeDays > 0)) {
+        throw new GenomeImportError("--max-eval-age must be a positive number of days");
+    }
+    let text;
+    try {
+        text = (0, node_fs_1.readFileSync)(file, "utf-8");
+    }
+    catch (err) {
+        throw new GenomeImportError(`Cannot read ${file}: ${err.message}`);
+    }
+    const { blueprint, plan, suggestedMinVg } = parseBlueprint(text);
+    const agentName = options.name ?? blueprint.metadata?.name;
+    if (typeof agentName !== "string" || agentName === "") {
+        throw new GenomeImportError("The Blueprint has no metadata.name", "Name the agent: --name <agent>");
+    }
+    const agentsDir = (0, node_path_1.join)(ctx.root, ".rotifer", "agents");
+    if ((0, node_fs_1.existsSync)(agentsDir)) {
+        const isTaken = (0, node_fs_1.readdirSync)(agentsDir)
+            .filter((f) => f.endsWith(".json"))
+            .some((f) => JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(agentsDir, f), "utf-8")).name === agentName);
+        if (isTaken)
+            throw new GenomeImportError(`An agent named '${agentName}' already exists`, "Pick another: --name <agent>");
+    }
+    const resolutions = [];
+    for (const role of plan.roles) {
+        try {
+            resolutions.push(await resolveRole(role, { blueprint, suggestedMinVg, options }));
+        }
+        catch (err) {
+            if (err instanceof capability_candidates_js_1.EvidenceError) {
+                throw new GenomeImportError(`Role '${role}': ${err.message}`, "Capability evidence could not be read; nothing was imported.");
+            }
+            throw err;
+        }
+    }
+    const names = resolutions.map((r) => r.name);
+    if (new Set(names).size !== names.length) {
+        throw new GenomeImportError("Two roles resolved to the same gene name; the agent cannot hold both");
+    }
+    const resolvedAt = (options.now ?? new Date()).toISOString();
+    if (options.isDryRun) {
+        return {
+            ok: true,
+            dryRun: true,
+            agent: null,
+            composition: plan.type,
+            executionSnapshot: null,
+            // Nothing is installed in a dry run, so no installed geneId is known yet.
+            roles: resolutions.map((r) => ({ ...r, geneId: null })),
+            schemaWarnings: [],
+        };
+    }
+    const genesRoot = (0, node_path_1.join)(ctx.root, ctx.genesDir);
+    (0, node_fs_1.mkdirSync)(genesRoot, { recursive: true });
+    const stagingRoot = (0, node_path_1.join)(ctx.root, ".rotifer", `import-staging-${(0, node_crypto_1.randomUUID)()}`);
+    (0, node_fs_1.mkdirSync)(stagingRoot, { recursive: true });
+    const schemaWarnings = [];
+    let staged;
+    try {
+        staged = await installAndVerify(resolutions, genesRoot, stagingRoot, !display.isJsonMode());
+        for (const s of staged) {
+            if (s.stagedDir)
+                (0, node_fs_1.cpSync)(s.stagedDir, (0, node_path_1.join)(genesRoot, s.name), { recursive: true });
+        }
+    }
+    finally {
+        // The staging directory is this command's own scratch space.
+        (0, node_fs_1.rmSync)(stagingRoot, { recursive: true, force: true });
+    }
+    const agent = (0, agent_create_js_1.createAgentCore)({
+        root: ctx.root,
+        genesDir: ctx.genesDir,
+        agentName,
+        genome: staged.map((s) => s.name),
+        compositionType: plan.type,
+        parMerge: plan.parMerge,
+        predicate: plan.predicate,
+        strategy: "genome-import",
+        onSchemaWarnings: (w) => schemaWarnings.push(...w),
+    });
+    return {
+        ok: true,
+        dryRun: false,
+        agent: { id: agent.id, name: agent.name },
+        composition: plan.type,
+        executionSnapshot: {
+            genomeId: genomeIdOf(blueprint),
+            resolvedDeps: Object.fromEntries(staged.map((s) => [s.role, s.geneId])),
+            resolvedAt,
+            status: "ACTIVE",
+        },
+        roles: resolutions.map((r, i) => ({ ...r, geneId: staged[i].geneId, contentHashCheck: staged[i].contentHashCheck })),
+        schemaWarnings,
+    };
+}
+function parseNumber(flag, raw) {
+    if (raw === undefined)
+        return undefined;
+    const n = Number(raw);
+    if (raw.trim() === "" || !Number.isFinite(n))
+        throw new GenomeImportError(`${flag} must be a number, got '${raw}'`);
+    return n;
+}
+function renderHuman(r) {
+    display.header(r.dryRun ? "Genome Import (dry run)" : "Genome Import");
+    display.keyValue("Composition", r.composition);
+    for (const role of r.roles) {
+        const mode = role.mode === "fallback" ? `fallback (${role.fallback})` : role.mode;
+        display.keyValue(`  ${role.role}`, `${mode} → ${role.owner}/${role.name}@${role.version}  ${role.cloudId}`);
+        display.keyValue("    original geneId", role.originalGeneId);
+        if (role.geneId)
+            display.keyValue("    installed geneId", role.geneId);
+        if (role.selfHealUpgrade)
+            display.keyValue("    self-heal upgrade", "yes");
+        if (role.crossAuthor)
+            display.keyValue("    cross-author", "yes");
+        if (role.evidence) {
+            const e = role.evidence;
+            display.keyValue("    evidence", `tier=${e.tier} fitness=${e.fitness_value} safety=${e.safety_score} (submitter-declared) ` +
+                `method=${e.evaluation_method} n=${e.evaluation_n} last=${e.last_evaluated}`);
+        }
+        for (const c of role.candidates ?? []) {
+            if (c.admitted)
+                continue;
+            display.hint(`    rejected ${c.owner}/${c.name}@${c.version}: ${c.rejections.map((x) => x.detail).join("; ")}`);
+        }
+        for (const s of role.rejectedSubstitutions ?? []) {
+            display.warn(`    substitute not taken ${s.owner}/${s.name}@${s.version}: ${s.reason}`);
+        }
+    }
+    for (const w of r.schemaWarnings)
+        display.warn(`Schema: ${w}`);
+    if (r.agent)
+        display.success(`Agent '${r.agent.name}' created (${r.agent.id})`);
+    else
+        display.hint("Dry run: nothing installed, no agent created.");
+}
+async function runGenomeImport(file, cli, ctx) {
+    try {
+        const isInteractive = !display.isJsonMode() && !!process.stdin.isTTY && !!process.stdout.isTTY;
+        const confirm = isInteractive
+            ? async (question) => {
+                const rl = (0, promises_1.createInterface)({ input: process.stdin, output: process.stdout });
+                try {
+                    return /^y(es)?$/i.test((await rl.question(`${question} [y/N] `)).trim());
+                }
+                finally {
+                    rl.close();
+                }
+            }
+            : undefined;
+        const result = await importGenome((0, node_path_1.resolve)(file), {
+            isPinned: cli.pinned,
+            isDryRun: cli.dryRun,
+            isConfirmed: cli.yes,
+            name: cli.name,
+            minVg: parseNumber("--min-vg", cli.minVg),
+            maxEvalAgeDays: parseNumber("--max-eval-age", cli.maxEvalAge),
+            confirm,
+        }, ctx);
+        display.renderResult(result, renderHuman);
+        return 0;
+    }
+    catch (err) {
+        if (!(err instanceof GenomeImportError)) {
+            const message = err?.message ?? String(err);
+            err = new GenomeImportError(message);
+        }
+        const e = err;
+        if (display.isJsonMode()) {
+            process.stdout.write(JSON.stringify({ ok: false, error: e.message, hint: e.hint }, null, 2) + "\n");
+        }
+        else {
+            display.error(e.message, e.hint);
+        }
+        return 1;
+    }
+}
+exports.genomeImportCommand = new commander_1.Command("import")
+    .description("Rebuild an agent from a Genome Blueprint (.rgenome)")
+    .argument("<file>", "Blueprint file")
+    .option("--pinned", "install exactly the genes the Blueprint pins; skip capability matching")
+    .option("--dry-run", "resolve every role and print the plan; install nothing")
+    .option("--yes", "accept substitutes from other authors without asking")
+    .option("--name <agent>", "name for the new agent (default: the Blueprint's)")
+    .option("--min-vg <n>", `V(g) threshold for capability picks, in [${genome_js_1.MIN_VG_FLOOR}, 1.0) (default ${exports.DEFAULT_MIN_VG}; the strictest of this, the Blueprint's and the default wins)`)
+    .option("--max-eval-age <days>", `ignore Arena evidence older than this (default ${exports.DEFAULT_MAX_EVAL_AGE_DAYS})`)
+    .action(async (file, cli) => {
+    const root = (0, project_root_js_1.requireProjectRoot)();
+    const config = (0, config_js_1.loadConfig)(root);
+    process.exitCode = await runGenomeImport(file, cli, { root, genesDir: config.genes_dir });
+});
+//# sourceMappingURL=genome-import.js.map