@wardby/cli 0.1.0

package/dist/import/bundle.js

@@ -0,0 +1,61 @@
+import { readFileSync, statSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { ManifestSchema, NeutralAgentSchema, NeutralToolSchema, NeutralAgentToolSchema, NeutralSecretSchema, NeutralAgentSecretSchema, NeutralSingleDatastoreSchema, NeutralSharedDatastoreSchema, NeutralWebhookSchema, NeutralBudgetSchema, } from "./neutral-schema.js";
+export class BundleError extends Error {
+}
+function readArray(dir, rel, schema) {
+    const p = join(dir, rel);
+    if (!existsSync(p))
+        return [];
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(p, "utf8"));
+    }
+    catch (e) {
+        throw new BundleError(`${rel}: invalid JSON (${e.message})`);
+    }
+    const parsed = z.array(schema).safeParse(raw);
+    if (!parsed.success)
+        throw new BundleError(`${rel}: ${parsed.error.issues[0]?.message ?? "schema mismatch"}`);
+    return parsed.data;
+}
+export function openBundle(dir) {
+    let st;
+    try {
+        st = statSync(dir);
+    }
+    catch {
+        throw new BundleError(`no such bundle directory: ${dir}`);
+    }
+    if (!st.isDirectory())
+        throw new BundleError(`bundle path is not a directory (extract the .zip first): ${dir}`);
+    const manifestPath = join(dir, "manifest.json");
+    if (!existsSync(manifestPath))
+        throw new BundleError("manifest.json not found in bundle");
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(manifestPath, "utf8"));
+    }
+    catch (e) {
+        throw new BundleError(`manifest.json: invalid JSON (${e.message})`);
+    }
+    const parsed = ManifestSchema.safeParse(raw);
+    if (!parsed.success)
+        throw new BundleError(`manifest.json: ${parsed.error.issues[0]?.message ?? "invalid"}`);
+    const manifest = parsed.data;
+    if (manifest.bundleVersion !== 1)
+        throw new BundleError(`unsupported bundleVersion ${manifest.bundleVersion}`);
+    return {
+        manifest,
+        readAgents: () => readArray(dir, "config/agents.json", NeutralAgentSchema),
+        readTools: () => readArray(dir, "config/tools.json", NeutralToolSchema),
+        readAgentTools: () => readArray(dir, "config/agent-tools.json", NeutralAgentToolSchema),
+        readSecrets: () => readArray(dir, "config/secrets.json", NeutralSecretSchema),
+        readAgentSecrets: () => readArray(dir, "config/agent-secrets.json", NeutralAgentSecretSchema),
+        readSingleDatastores: () => readArray(dir, "config/datastores-single.json", NeutralSingleDatastoreSchema),
+        readSharedDatastores: () => readArray(dir, "config/datastores-shared.json", NeutralSharedDatastoreSchema),
+        readWebhooks: () => readArray(dir, "config/webhooks.json", NeutralWebhookSchema),
+        readBudgets: () => readArray(dir, "capabilities/budgets.json", NeutralBudgetSchema),
+    };
+}

package/dist/import/cli-args.d.ts

@@ -0,0 +1,2 @@
+import type { ImportOptions } from "./index.js";
+export declare function parseImportArgs(args: string[]): Omit<ImportOptions, "db" | "env">;

package/dist/import/cli-args.js

@@ -0,0 +1,44 @@
+import { parseArgs } from "node:util";
+const VALID_CONFLICT_POLICIES = ["fail", "skip", "rename"];
+export function parseImportArgs(args) {
+    const { values, positionals } = parseArgs({
+        args,
+        allowPositionals: true,
+        options: {
+            owner: { type: "string" },
+            public: { type: "boolean" },
+            "include-secrets": { type: "boolean" },
+            "transfer-key": { type: "string" },
+            "default-budget": { type: "string" },
+            "dry-run": { type: "boolean" },
+            prefix: { type: "string" },
+            "on-conflict": { type: "string" },
+            "allow-open-fetch": { type: "boolean" },
+        },
+    });
+    // Require one positional: the bundle directory
+    if (positionals.length === 0) {
+        throw new Error("Missing bundle directory positional argument");
+    }
+    const dir = positionals[0];
+    // Parse owner/public
+    const isPublic = values.public ?? false;
+    const owner = isPublic ? null : (values.owner ?? null);
+    // Validate on-conflict
+    const onConflict = (values["on-conflict"] ?? "fail");
+    if (!VALID_CONFLICT_POLICIES.includes(onConflict)) {
+        throw new Error(`Invalid --on-conflict value "${onConflict}". Must be one of: ${VALID_CONFLICT_POLICIES.join(", ")}`);
+    }
+    return {
+        dir,
+        owner,
+        isPublic,
+        includeSecrets: values["include-secrets"] ?? false,
+        transferKeyPath: values["transfer-key"],
+        defaultBudget: values["default-budget"],
+        dryRun: values["dry-run"] ?? false,
+        prefix: values.prefix ?? "imported-",
+        onConflict,
+        allowOpenFetch: values["allow-open-fetch"] ?? false,
+    };
+}

package/dist/import/create.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Ordered idempotent create step — writes Tier-1 entities (tools, agents,
+ * attachments, secrets, datastores, webhooks, budget groups) to the database
+ * from a validated bundle + reconciliation.
+ */
+import type { PrismaClient } from "@prisma/client";
+import type { KeyObject } from "node:crypto";
+import type { Bundle } from "./bundle.js";
+import type { Reconciliation } from "./preflight.js";
+import type { SecretCipher } from "../providers/secrets/types.js";
+export interface CreateOptions {
+    db: PrismaClient;
+    cipher: SecretCipher;
+    ownerId: string | null;
+    defaultBudget: string;
+    secretMode: "references" | "envelope";
+    transferPrivateKey?: KeyObject;
+    allowOpenFetch: boolean;
+}
+export interface ImportResult {
+    agentsCreated: number;
+    toolsCreated: number;
+    secretsCreated: number;
+    datastoreEntries: number;
+    datastoresSharedCreated: number;
+    budgetGroupsCreated: number;
+    webhookSecrets: {
+        agentName: string;
+        secret: string;
+    }[];
+    pendingSecretReentry: string[];
+    warnings: string[];
+}
+export declare function createFromBundle(bundle: Bundle, recon: Reconciliation, opts: CreateOptions): Promise<ImportResult>;

package/dist/import/create.js

@@ -0,0 +1,363 @@
+/**
+ * Ordered idempotent create step — writes Tier-1 entities (tools, agents,
+ * attachments, secrets, datastores, webhooks, budget groups) to the database
+ * from a validated bundle + reconciliation.
+ */
+import { Prisma } from "@prisma/client";
+import { createSecret, attachSecret } from "../core/secrets.js";
+import { createDatastore, attachDatastore } from "../core/datastores.js";
+import { createWebhook } from "../core/webhooks.js";
+import { deriveJsonSchema } from "../sandbox/zod-params.js";
+import { ToolCapabilitiesPatchSchema, FETCH_WILDCARD } from "../sandbox/tool-capabilities.js";
+import { PostgresDatastore } from "../providers/datastore/postgres.js";
+import { decryptTransferEnvelope } from "../providers/secrets/transfer-envelope.js";
+import { mapBudget } from "./budgets.js";
+export async function createFromBundle(bundle, recon, opts) {
+    const { db, cipher, ownerId, secretMode, transferPrivateKey, allowOpenFetch } = opts;
+    const warnings = [];
+    const webhookSecrets = [];
+    const pendingSecretReentry = [];
+    const hasOwner = ownerId !== null;
+    // Helper: apply nameRemap
+    const eff = (name) => recon.nameRemap.get(name) ?? name;
+    // Helper: check if agent/tool was skipped/rejected
+    const agentSkipped = (name) => recon.agents.find((a) => a.name === name)?.skipped;
+    const agentDisabled = (name) => recon.agents.find((a) => a.name === name)?.disabled ?? false;
+    const toolRejected = (name) => recon.tools.find((t) => t.name === name)?.rejected;
+    const toolSkipped = (name) => recon.tools.find((t) => t.name === name)?.skipped;
+    // Track created entities
+    let toolsCreated = 0;
+    let agentsCreated = 0;
+    let secretsCreated = 0;
+    let datastoreEntries = 0;
+    let datastoresSharedCreated = 0;
+    let budgetGroupsCreated = 0;
+    // Step 1: Tools
+    const toolIdMap = new Map();
+    for (const t of bundle.readTools()) {
+        if (toolRejected(t.name) || toolSkipped(t.name))
+            continue;
+        const schema = await deriveJsonSchema(t.paramsZod);
+        if (!schema.ok) {
+            warnings.push(`tool ${t.name}: failed to derive JSON schema, skipping`);
+            continue;
+        }
+        const tool = await db.tool.upsert({
+            where: { name: eff(t.name) },
+            create: {
+                name: eff(t.name),
+                description: t.description,
+                paramsZod: t.paramsZod,
+                code: t.code,
+                jsonSchema: schema.value,
+                ownerId,
+            },
+            update: {},
+        });
+        toolIdMap.set(t.name, tool.id);
+        toolsCreated++;
+    }
+    // Step 2: Agents
+    const agentIdMap = new Map();
+    for (const a of bundle.readAgents()) {
+        if (agentSkipped(a.name))
+            continue;
+        const scheduleEnabled = agentDisabled(a.name) ? false : a.scheduleEnabled;
+        const agent = await db.agent.upsert({
+            where: { name: eff(a.name) },
+            create: {
+                name: eff(a.name),
+                model: a.model,
+                systemPrompt: a.systemPrompt,
+                budgetUsd: opts.defaultBudget,
+                schedule: a.schedule || null,
+                timezone: a.timezone,
+                maxTurns: a.maxTurns,
+                scheduleEnabled,
+                ownerId,
+            },
+            update: {},
+        });
+        agentIdMap.set(a.name, agent.id);
+        agentsCreated++;
+    }
+    // Step 3: Attach tools
+    for (const at of bundle.readAgentTools()) {
+        const agentId = agentIdMap.get(at.agentName);
+        const toolId = toolIdMap.get(at.toolName);
+        if (!agentId || !toolId) {
+            const missing = !agentId ? `agent ${at.agentName}` : `tool ${at.toolName}`;
+            warnings.push(`agent-tool ${at.agentName}/${at.toolName}: skipped — ${missing} was not imported`);
+            continue;
+        }
+        // Validate capabilities (drop "*" unless allowOpenFetch)
+        let allowedHosts = at.allowedHosts;
+        if (!allowOpenFetch) {
+            allowedHosts = allowedHosts.filter((h) => h !== FETCH_WILDCARD);
+        }
+        const capsPatch = ToolCapabilitiesPatchSchema.safeParse({
+            allowedSecrets: at.allowedSecrets,
+            allowedDatastorePrefixes: at.allowedDatastorePrefixes,
+            allowedHosts,
+            allowedSharedDatastorePrefixes: at.allowedSharedDatastorePrefixes,
+        });
+        if (!capsPatch.success) {
+            warnings.push(`agent-tool ${at.agentName}/${at.toolName}: invalid capabilities, skipping attachment`);
+            continue;
+        }
+        const caps = capsPatch.data;
+        await db.agentTool.upsert({
+            where: { agentId_toolId: { agentId, toolId } },
+            create: {
+                agentId,
+                toolId,
+                allowedSecrets: caps.allowedSecrets ?? [],
+                allowedDatastorePrefixes: caps.allowedDatastorePrefixes ?? [],
+                allowedHosts: caps.allowedHosts ?? [],
+                allowedSharedDatastorePrefixes: caps.allowedSharedDatastorePrefixes ?? {},
+            },
+            update: {
+                allowedSecrets: caps.allowedSecrets ?? [],
+                allowedDatastorePrefixes: caps.allowedDatastorePrefixes ?? [],
+                allowedHosts: caps.allowedHosts ?? [],
+                allowedSharedDatastorePrefixes: caps.allowedSharedDatastorePrefixes ?? {},
+            },
+        });
+    }
+    // Step 4: Secrets — one row per base secret, under its canonical name.
+    if (secretMode === "envelope") {
+        if (!hasOwner) {
+            for (const s of bundle.readSecrets()) {
+                warnings.push(`secret ${s.name}: skipped — secrets require an owner (public import)`);
+            }
+        }
+        else if (!transferPrivateKey) {
+            warnings.push("envelope mode requires transferPrivateKey, skipping secrets");
+        }
+        else {
+            const owner = ownerId; // hasOwner guarantees non-null
+            for (const s of bundle.readSecrets()) {
+                if (!s.ciphertext) {
+                    warnings.push(`secret ${s.name}: no ciphertext in envelope mode, skipping`);
+                    continue;
+                }
+                let plaintext;
+                try {
+                    // AAD is ALWAYS the base secret name (s.name), never an alias.
+                    plaintext = decryptTransferEnvelope(s.ciphertext, s.name, transferPrivateKey);
+                }
+                catch (err) {
+                    warnings.push(`secret ${s.name}: failed to decrypt (${err instanceof Error ? err.message : String(err)})`);
+                    continue;
+                }
+                try {
+                    await createSecret(s.name, plaintext, owner, cipher, db);
+                    secretsCreated++; // one per distinct base secret (fixes F1 over-count)
+                }
+                catch (err) {
+                    warnings.push(`secret ${s.name}: failed to create (${err instanceof Error ? err.message : String(err)})`);
+                }
+            }
+        }
+    }
+    else {
+        for (const s of bundle.readSecrets()) {
+            pendingSecretReentry.push(s.name);
+        }
+    }
+    // Step 5: Attach secrets (envelope mode only)
+    if (secretMode === "envelope" && hasOwner) {
+        const owner = ownerId;
+        for (const as of bundle.readAgentSecrets()) {
+            const agentId = agentIdMap.get(as.agentName);
+            if (!agentId)
+                continue;
+            const boundName = as.alias ?? as.secretName;
+            try {
+                await attachSecret(agentId, as.secretName, owner, db, boundName);
+            }
+            catch (err) {
+                if (err instanceof Prisma.PrismaClientKnownRequestError && err.code === "P2002") {
+                    // Either an idempotent re-run, or two secrets bound to the same
+                    // point-of-use name for one agent (a bundle inconsistency). Surface it.
+                    warnings.push(`agent-secret ${as.agentName}: "${boundName}" already bound — skipped (re-run or duplicate binding)`);
+                    continue;
+                }
+                warnings.push(`agent-secret ${as.agentName}/${as.secretName}: failed to attach (${err instanceof Error ? err.message : String(err)})`);
+            }
+        }
+    }
+    // Step 6: Per-agent datastore seed
+    const ds = new PostgresDatastore(db, cipher);
+    for (const d of bundle.readSingleDatastores()) {
+        const agentId = agentIdMap.get(d.agentName);
+        if (!agentId)
+            continue;
+        for (const entry of d.entries) {
+            try {
+                await ds.set(agentId, entry.key, entry.value, { pii: entry.pii });
+                datastoreEntries++;
+            }
+            catch (err) {
+                warnings.push(`datastore ${d.agentName}/${entry.key}: failed to set (${err instanceof Error ? err.message : String(err)})`);
+            }
+        }
+    }
+    // Step 6.5: Shared datastores — require an owner, same rule as
+    // secrets/webhooks/budgets: skip with a warning in public-import mode.
+    if (!hasOwner) {
+        for (const sd of bundle.readSharedDatastores()) {
+            warnings.push(`shared-datastore ${sd.name}: skipped — shared datastores require an owner (public import)`);
+        }
+    }
+    else {
+        const owner = ownerId; // hasOwner guarantees non-null
+        for (const sd of bundle.readSharedDatastores()) {
+            let created;
+            try {
+                created = await createDatastore(sd.name, owner, db);
+            }
+            catch (err) {
+                if (err instanceof Prisma.PrismaClientKnownRequestError && err.code === "P2002") {
+                    // Two shared-datastore definitions in this bundle collide on
+                    // (ownerId, name) — createDatastore isn't idempotent (Task 3).
+                    // Surface it and move on rather than aborting the whole import.
+                    warnings.push(`shared-datastore ${sd.name}: a datastore with this name already exists for this owner — skipped`);
+                    continue;
+                }
+                warnings.push(`shared-datastore ${sd.name}: failed to create (${err instanceof Error ? err.message : String(err)})`);
+                continue;
+            }
+            datastoresSharedCreated++;
+            for (const entry of sd.entries) {
+                try {
+                    await db.datastoreEntry.create({
+                        data: { datastoreId: created.id, key: entry.key, value: entry.value, pii: false },
+                    });
+                }
+                catch (err) {
+                    warnings.push(`shared-datastore ${sd.name}/${entry.key}: failed to seed (${err instanceof Error ? err.message : String(err)})`);
+                }
+            }
+            for (const agentName of sd.attachedAgentNames) {
+                const agentId = agentIdMap.get(agentName);
+                if (!agentId)
+                    continue;
+                try {
+                    await attachDatastore(agentId, created.id, db, sd.name);
+                }
+                catch (err) {
+                    if (err instanceof Prisma.PrismaClientKnownRequestError && err.code === "P2002") {
+                        warnings.push(`shared-datastore ${sd.name}: agent ${agentName} already binds "${sd.name}" — skipped`);
+                        continue;
+                    }
+                    warnings.push(`shared-datastore ${sd.name}/${agentName}: failed to attach (${err instanceof Error ? err.message : String(err)})`);
+                }
+            }
+        }
+    }
+    // Step 7: Webhooks
+    if (!hasOwner) {
+        // Webhooks require an owner - skip in public import mode
+        for (const w of bundle.readWebhooks()) {
+            warnings.push(`webhook for agent ${w.agentName}: skipped — webhooks require an owner (public import)`);
+        }
+    }
+    else {
+        const owner = ownerId; // TypeScript narrowing: hasOwner guarantees non-null
+        for (const w of bundle.readWebhooks()) {
+            const agentId = agentIdMap.get(w.agentName);
+            if (!agentId)
+                continue;
+            try {
+                // Check if webhook already exists (idempotency)
+                const existing = await db.webhook.findFirst({ where: { agentId } });
+                if (existing)
+                    continue;
+                const { id, secret } = await createWebhook(agentId, owner, db);
+                webhookSecrets.push({ agentName: w.agentName, secret });
+                if (!w.enabled) {
+                    await db.webhook.update({
+                        where: { id },
+                        data: { status: "disabled" },
+                    });
+                }
+            }
+            catch (err) {
+                warnings.push(`webhook ${w.agentName}: failed to create (${err instanceof Error ? err.message : String(err)})`);
+            }
+        }
+    }
+    // Step 8: Budget groups
+    if (!hasOwner) {
+        // Budget groups require an owner - skip in public import mode
+        for (const b of bundle.readBudgets()) {
+            const mapped = mapBudget(b);
+            if (mapped.ok) {
+                warnings.push(`budget group ${mapped.group.name}: skipped — budget groups require an owner (public import)`);
+            }
+        }
+    }
+    else {
+        const owner = ownerId; // TypeScript narrowing: hasOwner guarantees non-null
+        const budgetGroupMap = new Map(); // budget name -> groupId
+        const agentBudgetAssignments = new Map(); // agent name -> first budget that claimed it
+        for (const b of bundle.readBudgets()) {
+            const mapped = mapBudget(b);
+            if (!mapped.ok)
+                continue;
+            const { group, agentNames } = mapped;
+            try {
+                const bg = await db.budgetGroup.upsert({
+                    where: { ownerId_name: { ownerId: owner, name: group.name } },
+                    create: {
+                        name: group.name,
+                        ownerId: owner,
+                        dailyBudgetUsd: group.dailyBudgetUsd,
+                        weeklyBudgetUsd: group.weeklyBudgetUsd,
+                        monthlyBudgetUsd: group.monthlyBudgetUsd,
+                        warnThresholdRatio: group.warnThresholdRatio,
+                    },
+                    update: {},
+                });
+                budgetGroupMap.set(group.name, bg.id);
+                budgetGroupsCreated++;
+                // Attach agents (first budget wins)
+                for (const agentName of agentNames) {
+                    const agentId = agentIdMap.get(agentName);
+                    if (!agentId)
+                        continue;
+                    const existingBudget = agentBudgetAssignments.get(agentName);
+                    if (existingBudget) {
+                        warnings.push(`agent ${agentName}: already in budget group "${existingBudget}", ignoring "${group.name}"`);
+                        continue;
+                    }
+                    try {
+                        await db.agent.update({
+                            where: { id: agentId },
+                            data: { budgetGroupId: bg.id },
+                        });
+                        agentBudgetAssignments.set(agentName, group.name);
+                    }
+                    catch (err) {
+                        warnings.push(`agent ${agentName}: failed to attach to budget group "${group.name}" (${err instanceof Error ? err.message : String(err)})`);
+                    }
+                }
+            }
+            catch (err) {
+                warnings.push(`budget group ${group.name}: failed to create (${err instanceof Error ? err.message : String(err)})`);
+            }
+        }
+    }
+    return {
+        agentsCreated,
+        toolsCreated,
+        secretsCreated,
+        datastoreEntries,
+        datastoresSharedCreated,
+        budgetGroupsCreated,
+        webhookSecrets,
+        pendingSecretReentry,
+        warnings,
+    };
+}

package/dist/import/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Top-level orchestrator: opens a bundle, runs preflight reconciliation,
+ * renders the report, and (unless dry-run or fatal collision) creates entities.
+ */
+import type { PrismaClient } from "@prisma/client";
+import type { ConflictPolicy } from "./preflight.js";
+import { type ImportResult } from "./create.js";
+export interface ImportOptions {
+    dir: string;
+    owner: string | null;
+    isPublic: boolean;
+    includeSecrets: boolean;
+    transferKeyPath?: string;
+    defaultBudget?: string;
+    dryRun: boolean;
+    prefix: string;
+    onConflict: ConflictPolicy;
+    allowOpenFetch: boolean;
+    db: PrismaClient;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function runImport(opts: ImportOptions): Promise<{
+    report: string;
+    result?: ImportResult;
+}>;

package/dist/import/index.js

@@ -0,0 +1,130 @@
+/**
+ * Top-level orchestrator: opens a bundle, runs preflight reconciliation,
+ * renders the report, and (unless dry-run or fatal collision) creates entities.
+ */
+import { openBundle } from "./bundle.js";
+import { preflight } from "./preflight.js";
+import { renderReconciliation } from "./report.js";
+import { createFromBundle } from "./create.js";
+import { supportedGlobalsFromPrelude } from "./tool-scan.js";
+import { SANDBOX_PRELUDE } from "../sandbox/prelude.js";
+import { resolveLlmRegistrations } from "../providers/llm/registration.js";
+import { RoutingLlmProvider } from "../providers/llm/routing.js";
+import { loadProviderConfig } from "../config/providers.js";
+import { buildSecretCipher } from "../providers/secrets/index.js";
+import { resolvePrincipal } from "../mcp/auth/principal.js";
+import { loadTransferPrivateKey, transferKeyIdOf } from "../providers/secrets/transfer-envelope.js";
+import { readFileSync } from "node:fs";
+export async function runImport(opts) {
+    const env = opts.env ?? process.env;
+    // Guard: owner XOR public
+    if (opts.owner === null && !opts.isPublic) {
+        throw new Error("Must specify either --owner or --public (not neither)");
+    }
+    if (opts.owner !== null && opts.isPublic) {
+        throw new Error("Cannot specify both --owner and --public");
+    }
+    // Open bundle
+    const bundle = openBundle(opts.dir);
+    // Determine effective secret mode: envelope only if bundle is envelope AND --include-secrets
+    const effectiveSecretMode = bundle.manifest.secretMode === "envelope" && opts.includeSecrets ? "envelope" : "references";
+    // Build routableModels from LLM registrations
+    const reg = resolveLlmRegistrations(env);
+    const routableModels = reg.kind === "registrations" ? new Set(new RoutingLlmProvider(reg.registrations).listModels()) : new Set();
+    // Get supportedGlobals from prelude
+    const supportedGlobals = supportedGlobalsFromPrelude(SANDBOX_PRELUDE);
+    // Load existing names from db
+    const existingAgents = await opts.db.agent.findMany({ select: { name: true } });
+    const existingAgentNames = new Set(existingAgents.map((a) => a.name));
+    const existingTools = await opts.db.tool.findMany({ select: { name: true } });
+    const existingToolNames = new Set(existingTools.map((t) => t.name));
+    // For owner-scoped entities (secrets, budgets), load only if we have an owner
+    const ownerId = opts.owner !== null && !opts.isPublic ? (await resolvePrincipal(opts.owner, opts.db)).id : null;
+    // Tier-1 capabilities: "budgets" and "shared-datastores" are implemented
+    const capabilitiesSupported = new Set(["budgets", "shared-datastores"]);
+    // Run preflight reconciliation
+    const recon = preflight({
+        bundle,
+        routableModels,
+        supportedGlobals,
+        existingAgentNames,
+        existingToolNames,
+        capabilitiesSupported,
+        onConflict: opts.onConflict,
+        prefix: opts.prefix,
+        allowOpenFetch: opts.allowOpenFetch,
+    });
+    // Render initial report
+    let report = renderReconciliation(recon, {
+        secretMode: bundle.manifest.secretMode,
+        dryRun: opts.dryRun,
+    });
+    // Early return if dry-run or fatal collision
+    if (recon.hasFatalCollision && !opts.dryRun) {
+        report +=
+            "\n\n*** Import aborted: a name collision was found under --on-conflict fail. No changes were written. ***";
+        return { report };
+    }
+    if (opts.dryRun || recon.hasFatalCollision) {
+        return { report };
+    }
+    // Load and verify transfer key (only when actually importing secrets from envelope)
+    let transferPrivateKey = undefined;
+    if (effectiveSecretMode === "envelope") {
+        if (!opts.transferKeyPath) {
+            throw new Error("Importing secrets from an envelope bundle requires --transfer-key");
+        }
+        const keyPem = readFileSync(opts.transferKeyPath, "utf8");
+        transferPrivateKey = loadTransferPrivateKey(keyPem);
+        const keyId = transferKeyIdOf(transferPrivateKey);
+        if (keyId !== bundle.manifest.transferKeyId) {
+            throw new Error(`Transfer key ID mismatch: key has ${keyId}, bundle manifest declares ${bundle.manifest.transferKeyId}`);
+        }
+    }
+    // Build secret cipher
+    const providerConfig = loadProviderConfig(env);
+    const cipher = buildSecretCipher(providerConfig, env);
+    // Run create
+    const result = await createFromBundle(bundle, recon, {
+        db: opts.db,
+        cipher,
+        ownerId,
+        defaultBudget: opts.defaultBudget ?? "10.00",
+        secretMode: effectiveSecretMode,
+        transferPrivateKey,
+        allowOpenFetch: opts.allowOpenFetch,
+    });
+    // Append final report sections
+    const finalLines = [];
+    finalLines.push("");
+    finalLines.push("--- Import Complete ---");
+    finalLines.push(`Agents created: ${result.agentsCreated}`);
+    finalLines.push(`Tools created: ${result.toolsCreated}`);
+    finalLines.push(`Secrets created: ${result.secretsCreated}`);
+    finalLines.push(`Datastore entries: ${result.datastoreEntries}`);
+    finalLines.push(`Shared datastores created: ${result.datastoresSharedCreated}`);
+    finalLines.push(`Budget groups created: ${result.budgetGroupsCreated}`);
+    if (result.webhookSecrets.length > 0) {
+        finalLines.push("");
+        finalLines.push("Webhook secrets (save these now, they won't be shown again):");
+        for (const ws of result.webhookSecrets) {
+            finalLines.push(`  ${ws.agentName}: ${ws.secret}`);
+        }
+    }
+    if (result.pendingSecretReentry.length > 0) {
+        finalLines.push("");
+        finalLines.push("Pending secret re-entry (references mode):");
+        for (const name of result.pendingSecretReentry) {
+            finalLines.push(`  - ${name}`);
+        }
+    }
+    if (result.warnings.length > 0) {
+        finalLines.push("");
+        finalLines.push("Warnings:");
+        for (const w of result.warnings) {
+            finalLines.push(`  - ${w}`);
+        }
+    }
+    report += "\n" + finalLines.join("\n");
+    return { report, result };
+}

package/dist/import/model-gate.d.ts

@@ -0,0 +1 @@
+export declare function classifyModel(model: string, routableModels: ReadonlySet<string>): "routable" | "unroutable";

package/dist/import/model-gate.js

@@ -0,0 +1,3 @@
+export function classifyModel(model, routableModels) {
+    return routableModels.has(model) ? "routable" : "unroutable";
+}