@wardby/cli 0.1.0

package/dist/import/neutral-schema.d.ts

@@ -0,0 +1,369 @@
+import { z } from "zod";
+export declare const CiphertextSchema: z.ZodObject<{
+    v: z.ZodNumber;
+    alg: z.ZodString;
+    epk: z.ZodString;
+    nonce: z.ZodString;
+    ct: z.ZodString;
+    tag: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    tag: string;
+    v: number;
+    alg: string;
+    epk: string;
+    nonce: string;
+    ct: string;
+}, {
+    tag: string;
+    v: number;
+    alg: string;
+    epk: string;
+    nonce: string;
+    ct: string;
+}>;
+export declare const ManifestSchema: z.ZodObject<{
+    bundleVersion: z.ZodNumber;
+    source: z.ZodObject<{
+        product: z.ZodString;
+        exporterVersion: z.ZodString;
+        exportedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        product: string;
+        exporterVersion: string;
+        exportedAt: string;
+    }, {
+        product: string;
+        exporterVersion: string;
+        exportedAt: string;
+    }>;
+    secretMode: z.ZodEnum<["references", "envelope"]>;
+    transferKeyId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    contentWindowDays: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    contentSince: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    toolCallDetail: z.ZodDefault<z.ZodEnum<["metadata", "full"]>>;
+    runAuditWindowDays: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    runAuditSince: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    capabilities: z.ZodArray<z.ZodString, "many">;
+    counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    capabilities: string[];
+    bundleVersion: number;
+    source: {
+        product: string;
+        exporterVersion: string;
+        exportedAt: string;
+    };
+    secretMode: "references" | "envelope";
+    transferKeyId: string | null;
+    contentWindowDays: number | null;
+    contentSince: string | null;
+    toolCallDetail: "metadata" | "full";
+    runAuditWindowDays: number | null;
+    runAuditSince: string | null;
+    counts: Record<string, number>;
+}, {
+    capabilities: string[];
+    bundleVersion: number;
+    source: {
+        product: string;
+        exporterVersion: string;
+        exportedAt: string;
+    };
+    secretMode: "references" | "envelope";
+    counts: Record<string, number>;
+    transferKeyId?: string | null | undefined;
+    contentWindowDays?: number | null | undefined;
+    contentSince?: string | null | undefined;
+    toolCallDetail?: "metadata" | "full" | undefined;
+    runAuditWindowDays?: number | null | undefined;
+    runAuditSince?: string | null | undefined;
+}>;
+export type Manifest = z.infer<typeof ManifestSchema>;
+export declare const NeutralAgentSchema: z.ZodObject<{
+    name: z.ZodString;
+    systemPrompt: z.ZodString;
+    provider: z.ZodEnum<["openai", "bedrock"]>;
+    model: z.ZodString;
+    region: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    schedule: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    timezone: z.ZodDefault<z.ZodString>;
+    scheduleEnabled: z.ZodBoolean;
+    maxTurns: z.ZodNumber;
+    budgetUsd: z.ZodString;
+    ownerEmail: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodDefault<z.ZodEnum<["native"]>>;
+    memoryEnabled: z.ZodDefault<z.ZodBoolean>;
+    unmodeled: z.ZodDefault<z.ZodObject<{
+        description: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
+        slug: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodString>>>;
+        emailAllowlist: z.ZodOptional<z.ZodDefault<z.ZodNullable<z.ZodUnknown>>>;
+    }, "strip", z.ZodTypeAny, {
+        description?: string | null | undefined;
+        slug?: string | null | undefined;
+        emailAllowlist?: unknown;
+    }, {
+        description?: string | null | undefined;
+        slug?: string | null | undefined;
+        emailAllowlist?: unknown;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    model: string;
+    budgetUsd: string;
+    systemPrompt: string;
+    kind: "native";
+    schedule: string | null;
+    timezone: string;
+    scheduleEnabled: boolean;
+    maxTurns: number;
+    memoryEnabled: boolean;
+    provider: "openai" | "bedrock";
+    region: string | null;
+    ownerEmail: string | null;
+    unmodeled: {
+        description?: string | null | undefined;
+        slug?: string | null | undefined;
+        emailAllowlist?: unknown;
+    };
+}, {
+    name: string;
+    model: string;
+    budgetUsd: string;
+    systemPrompt: string;
+    scheduleEnabled: boolean;
+    maxTurns: number;
+    provider: "openai" | "bedrock";
+    kind?: "native" | undefined;
+    schedule?: string | null | undefined;
+    timezone?: string | undefined;
+    memoryEnabled?: boolean | undefined;
+    region?: string | null | undefined;
+    ownerEmail?: string | null | undefined;
+    unmodeled?: {
+        description?: string | null | undefined;
+        slug?: string | null | undefined;
+        emailAllowlist?: unknown;
+    } | undefined;
+}>;
+export type NeutralAgent = z.infer<typeof NeutralAgentSchema>;
+export declare const NeutralToolSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodDefault<z.ZodString>;
+    paramsZod: z.ZodString;
+    jsonSchema: z.ZodDefault<z.ZodNullable<z.ZodUnknown>>;
+    code: z.ZodString;
+    secretSchema: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    code: string;
+    description: string;
+    paramsZod: string;
+    secretSchema: string;
+    jsonSchema?: unknown;
+}, {
+    name: string;
+    code: string;
+    paramsZod: string;
+    description?: string | undefined;
+    jsonSchema?: unknown;
+    secretSchema?: string | undefined;
+}>;
+export type NeutralTool = z.infer<typeof NeutralToolSchema>;
+export declare const NeutralAgentToolSchema: z.ZodObject<{
+    agentName: z.ZodString;
+    toolName: z.ZodString;
+    allowedSecrets: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    allowedDatastorePrefixes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    allowedHosts: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    allowedSharedDatastorePrefixes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    hostsSource: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    allowedSecrets: string[];
+    allowedDatastorePrefixes: string[];
+    allowedHosts: string[];
+    allowedSharedDatastorePrefixes: Record<string, string[]>;
+    agentName: string;
+    toolName: string;
+    hostsSource?: string | undefined;
+}, {
+    agentName: string;
+    toolName: string;
+    allowedSecrets?: string[] | undefined;
+    allowedDatastorePrefixes?: string[] | undefined;
+    allowedHosts?: string[] | undefined;
+    allowedSharedDatastorePrefixes?: Record<string, string[]> | undefined;
+    hostsSource?: string | undefined;
+}>;
+export type NeutralAgentTool = z.infer<typeof NeutralAgentToolSchema>;
+export declare const NeutralSecretSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    ownerEmail: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    ciphertext: z.ZodOptional<z.ZodObject<{
+        v: z.ZodNumber;
+        alg: z.ZodString;
+        epk: z.ZodString;
+        nonce: z.ZodString;
+        ct: z.ZodString;
+        tag: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        tag: string;
+        v: number;
+        alg: string;
+        epk: string;
+        nonce: string;
+        ct: string;
+    }, {
+        tag: string;
+        v: number;
+        alg: string;
+        epk: string;
+        nonce: string;
+        ct: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string | null;
+    ownerEmail: string | null;
+    ciphertext?: {
+        tag: string;
+        v: number;
+        alg: string;
+        epk: string;
+        nonce: string;
+        ct: string;
+    } | undefined;
+}, {
+    name: string;
+    ciphertext?: {
+        tag: string;
+        v: number;
+        alg: string;
+        epk: string;
+        nonce: string;
+        ct: string;
+    } | undefined;
+    description?: string | null | undefined;
+    ownerEmail?: string | null | undefined;
+}>;
+export type NeutralSecret = z.infer<typeof NeutralSecretSchema>;
+export declare const NeutralAgentSecretSchema: z.ZodObject<{
+    agentName: z.ZodString;
+    secretName: z.ZodString;
+    alias: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    agentName: string;
+    secretName: string;
+    alias: string | null;
+}, {
+    agentName: string;
+    secretName: string;
+    alias?: string | null | undefined;
+}>;
+export type NeutralAgentSecret = z.infer<typeof NeutralAgentSecretSchema>;
+export declare const NeutralSingleDatastoreSchema: z.ZodObject<{
+    agentName: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    entries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodUnknown;
+        pii: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        pii: boolean;
+        value?: unknown;
+    }, {
+        key: string;
+        value?: unknown;
+        pii?: boolean | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    entries: {
+        key: string;
+        pii: boolean;
+        value?: unknown;
+    }[];
+    agentName: string;
+    name?: string | undefined;
+}, {
+    agentName: string;
+    name?: string | undefined;
+    entries?: {
+        key: string;
+        value?: unknown;
+        pii?: boolean | undefined;
+    }[] | undefined;
+}>;
+export type NeutralSingleDatastore = z.infer<typeof NeutralSingleDatastoreSchema>;
+export declare const NeutralSharedDatastoreSchema: z.ZodObject<{
+    name: z.ZodString;
+    ownerEmail: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    attachedAgentNames: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    entries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        value?: unknown;
+    }, {
+        key: string;
+        value?: unknown;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    entries: {
+        key: string;
+        value?: unknown;
+    }[];
+    ownerEmail: string | null;
+    attachedAgentNames: string[];
+}, {
+    name: string;
+    entries?: {
+        key: string;
+        value?: unknown;
+    }[] | undefined;
+    ownerEmail?: string | null | undefined;
+    attachedAgentNames?: string[] | undefined;
+}>;
+export type NeutralSharedDatastore = z.infer<typeof NeutralSharedDatastoreSchema>;
+export declare const NeutralWebhookSchema: z.ZodObject<{
+    agentName: z.ZodString;
+    enabled: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    agentName: string;
+    enabled: boolean;
+}, {
+    agentName: string;
+    enabled: boolean;
+}>;
+export type NeutralWebhook = z.infer<typeof NeutralWebhookSchema>;
+export declare const NeutralBudgetSchema: z.ZodObject<{
+    name: z.ZodString;
+    ownerEmail: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    period: z.ZodEnum<["daily", "weekly", "monthly"]>;
+    alertThreshold: z.ZodString;
+    blockThreshold: z.ZodString;
+    alertEmails: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    enabled: z.ZodBoolean;
+    attachedAgentNames: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    period: "daily" | "weekly" | "monthly";
+    enabled: boolean;
+    ownerEmail: string | null;
+    attachedAgentNames: string[];
+    alertThreshold: string;
+    blockThreshold: string;
+    alertEmails: string[];
+}, {
+    name: string;
+    period: "daily" | "weekly" | "monthly";
+    enabled: boolean;
+    alertThreshold: string;
+    blockThreshold: string;
+    ownerEmail?: string | null | undefined;
+    attachedAgentNames?: string[] | undefined;
+    alertEmails?: string[] | undefined;
+}>;
+export type NeutralBudget = z.infer<typeof NeutralBudgetSchema>;

package/dist/import/neutral-schema.js

@@ -0,0 +1,109 @@
+import { z } from "zod";
+export const CiphertextSchema = z.object({
+    v: z.number(),
+    alg: z.string(),
+    epk: z.string(),
+    nonce: z.string(),
+    ct: z.string(),
+    tag: z.string(),
+});
+export const ManifestSchema = z.object({
+    bundleVersion: z.number(),
+    source: z.object({ product: z.string(), exporterVersion: z.string(), exportedAt: z.string() }),
+    secretMode: z.enum(["references", "envelope"]),
+    transferKeyId: z.string().nullable().default(null),
+    contentWindowDays: z.number().nullable().default(null),
+    contentSince: z.string().nullable().default(null),
+    toolCallDetail: z.enum(["metadata", "full"]).default("metadata"),
+    runAuditWindowDays: z.number().nullable().default(null),
+    runAuditSince: z.string().nullable().default(null),
+    capabilities: z.array(z.string()),
+    counts: z.record(z.string(), z.number()),
+});
+export const NeutralAgentSchema = z.object({
+    name: z.string(),
+    systemPrompt: z.string(),
+    provider: z.enum(["openai", "bedrock"]),
+    model: z.string(),
+    region: z.string().nullable().default(null),
+    schedule: z.string().nullable().default(null), // "" or null both mean manual-only
+    timezone: z.string().default("UTC"),
+    scheduleEnabled: z.boolean(),
+    maxTurns: z.number().int(),
+    budgetUsd: z.string(),
+    ownerEmail: z.string().nullable().default(null),
+    kind: z.enum(["native"]).default("native"),
+    memoryEnabled: z.boolean().default(false),
+    unmodeled: z
+        .object({
+        description: z.string().nullable().default(null),
+        slug: z.string().nullable().default(null),
+        emailAllowlist: z.unknown().nullable().default(null),
+    })
+        .partial()
+        .default({}),
+});
+export const NeutralToolSchema = z.object({
+    name: z.string(),
+    description: z.string().default(""),
+    paramsZod: z.string(),
+    jsonSchema: z.unknown().nullable().default(null), // ignored; we re-derive (ruling 2)
+    code: z.string(),
+    secretSchema: z.string().default(""),
+});
+export const NeutralAgentToolSchema = z.object({
+    agentName: z.string(),
+    toolName: z.string(),
+    allowedSecrets: z.array(z.string()).default([]),
+    allowedDatastorePrefixes: z.array(z.string()).default([]),
+    allowedHosts: z.array(z.string()).default([]),
+    allowedSharedDatastorePrefixes: z.record(z.string(), z.array(z.string())).default({}),
+    hostsSource: z.string().optional(),
+});
+export const NeutralSecretSchema = z.object({
+    name: z.string(),
+    description: z.string().nullable().default(null),
+    ownerEmail: z.string().nullable().default(null),
+    ciphertext: CiphertextSchema.optional(),
+});
+export const NeutralAgentSecretSchema = z.object({
+    agentName: z.string(),
+    secretName: z.string(),
+    alias: z.string().nullable().default(null),
+});
+export const NeutralSingleDatastoreSchema = z.object({
+    agentName: z.string(),
+    name: z.string().optional(),
+    entries: z
+        .array(z.object({
+        key: z.string(),
+        value: z.unknown(),
+        pii: z.boolean().default(false),
+    }))
+        .default([]),
+});
+export const NeutralSharedDatastoreSchema = z.object({
+    name: z.string(),
+    ownerEmail: z.string().nullable().default(null),
+    attachedAgentNames: z.array(z.string()).default([]),
+    entries: z
+        .array(z.object({
+        key: z.string(),
+        value: z.unknown(),
+    }))
+        .default([]),
+});
+export const NeutralWebhookSchema = z.object({
+    agentName: z.string(),
+    enabled: z.boolean(),
+});
+export const NeutralBudgetSchema = z.object({
+    name: z.string(),
+    ownerEmail: z.string().nullable().default(null),
+    period: z.enum(["daily", "weekly", "monthly"]),
+    alertThreshold: z.string(),
+    blockThreshold: z.string(),
+    alertEmails: z.array(z.string()).default([]),
+    enabled: z.boolean(),
+    attachedAgentNames: z.array(z.string()).default([]),
+});

package/dist/import/preflight.d.ts

@@ -0,0 +1,41 @@
+import type { Bundle } from "./bundle.js";
+export type ConflictPolicy = "fail" | "skip" | "rename";
+export interface PreflightInput {
+    bundle: Bundle;
+    routableModels: ReadonlySet<string>;
+    supportedGlobals: ReadonlySet<string>;
+    existingAgentNames: ReadonlySet<string>;
+    existingToolNames: ReadonlySet<string>;
+    capabilitiesSupported: ReadonlySet<string>;
+    onConflict: ConflictPolicy;
+    prefix: string;
+    allowOpenFetch: boolean;
+}
+export interface Reconciliation {
+    nameRemap: Map<string, string>;
+    agents: {
+        name: string;
+        disabled: boolean;
+        disabledReason?: string;
+        skipped?: string;
+    }[];
+    tools: {
+        name: string;
+        rejected?: string;
+        skipped?: string;
+    }[];
+    skippedCapabilities: string[];
+    budgets: {
+        name: string;
+        skippedReason?: string;
+    }[];
+    collisions: {
+        kind: "agent" | "tool";
+        name: string;
+        action: ConflictPolicy;
+        newName?: string;
+    }[];
+    notes: string[];
+    hasFatalCollision: boolean;
+}
+export declare function preflight(input: PreflightInput): Reconciliation;

package/dist/import/preflight.js

@@ -0,0 +1,71 @@
+import { classifyModel } from "./model-gate.js";
+import { scanToolCode } from "./tool-scan.js";
+import { mapBudget } from "./budgets.js";
+export function preflight(input) {
+    const { bundle, onConflict, prefix } = input;
+    const nameRemap = new Map();
+    const collisions = [];
+    const notes = [];
+    let hasFatalCollision = false;
+    const resolveCollision = (kind, name, existing) => {
+        if (!existing.has(name))
+            return { skipped: undefined };
+        if (onConflict === "fail") {
+            hasFatalCollision = true;
+            collisions.push({ kind, name, action: "fail" });
+            return { skipped: "collision" };
+        }
+        if (onConflict === "skip") {
+            collisions.push({ kind, name, action: "skip" });
+            return { skipped: "collision" };
+        }
+        const newName = prefix + name;
+        // Rename target must itself be free; otherwise the upsert would adopt an
+        // unrelated pre-existing row. Treat an occupied target as a fatal collision.
+        if (existing.has(newName)) {
+            hasFatalCollision = true;
+            collisions.push({ kind, name, action: "fail" });
+            notes.push(`${kind} ${name}: rename target "${newName}" already exists — cannot resolve collision`);
+            return { skipped: "collision" };
+        }
+        nameRemap.set(name, newName);
+        collisions.push({ kind, name, action: "rename", newName });
+        return { skipped: undefined };
+    };
+    const agents = bundle.readAgents().map((a) => {
+        const c = resolveCollision("agent", a.name, input.existingAgentNames);
+        if (c.skipped === "collision")
+            return { name: a.name, disabled: false, skipped: "collision" };
+        const routable = classifyModel(a.model, input.routableModels) === "routable";
+        // Controller Ruling B: disabled flag reflects MODEL ROUTABILITY ONLY
+        return routable
+            ? { name: a.name, disabled: false }
+            : {
+                name: a.name,
+                disabled: true,
+                disabledReason: `model ${a.model} not routable — no registered provider serves it`,
+            };
+    });
+    const tools = bundle.readTools().map((t) => {
+        const c = resolveCollision("tool", t.name, input.existingToolNames);
+        if (c.skipped === "collision")
+            return { name: t.name, skipped: "collision" };
+        const scan = scanToolCode(t.code, input.supportedGlobals);
+        return scan.ok
+            ? { name: t.name }
+            : { name: t.name, rejected: `uses unsupported host API: ${scan.rejectedApis.join(", ")}` };
+    });
+    const skippedCapabilities = bundle.manifest.capabilities.filter((c) => !input.capabilitiesSupported.has(c));
+    const budgets = bundle.readBudgets().map((b) => {
+        const m = mapBudget(b);
+        return m.ok ? { name: b.name } : { name: b.name, skippedReason: m.reason };
+    });
+    if (!input.allowOpenFetch) {
+        for (const at of bundle.readAgentTools()) {
+            if (at.allowedHosts.includes("*")) {
+                notes.push(`agent-tool ${at.agentName}/${at.toolName}: "*" host dropped (no --allow-open-fetch)`);
+            }
+        }
+    }
+    return { nameRemap, agents, tools, skippedCapabilities, budgets, collisions, notes, hasFatalCollision };
+}

package/dist/import/report.d.ts

@@ -0,0 +1,5 @@
+import type { Reconciliation } from "./preflight.js";
+export declare function renderReconciliation(r: Reconciliation, opts: {
+    secretMode: "references" | "envelope";
+    dryRun: boolean;
+}): string;

package/dist/import/report.js

@@ -0,0 +1,98 @@
+export function renderReconciliation(r, opts) {
+    const lines = [];
+    // Dry run banner
+    if (opts.dryRun) {
+        lines.push("DRY RUN — no changes written");
+        lines.push("");
+    }
+    // Secret mode notice
+    lines.push(`Secret mode: ${opts.secretMode}`);
+    lines.push("");
+    // Agents
+    lines.push("Agents:");
+    const disabledAgents = r.agents.filter((a) => a.disabled || a.skipped);
+    if (disabledAgents.length > 0) {
+        for (const a of disabledAgents) {
+            if (a.disabled && a.disabledReason) {
+                lines.push(`  - ${a.name} (disabled): ${a.disabledReason}`);
+            }
+            else if (a.skipped) {
+                lines.push(`  - ${a.name}: skipped (${a.skipped})`);
+            }
+        }
+    }
+    else {
+        lines.push("  (all agents importable)");
+    }
+    lines.push("");
+    // Tools
+    lines.push("Tools:");
+    const rejectedTools = r.tools.filter((t) => t.rejected || t.skipped);
+    if (rejectedTools.length > 0) {
+        for (const t of rejectedTools) {
+            if (t.rejected) {
+                lines.push(`  - ${t.name} (rejected): ${t.rejected}`);
+            }
+            else if (t.skipped) {
+                lines.push(`  - ${t.name}: skipped (${t.skipped})`);
+            }
+        }
+    }
+    else {
+        lines.push("  (all tools importable)");
+    }
+    lines.push("");
+    // Skipped capabilities
+    lines.push("Skipped capabilities:");
+    if (r.skippedCapabilities.length > 0) {
+        for (const cap of r.skippedCapabilities) {
+            lines.push(`  - ${cap}`);
+        }
+    }
+    else {
+        lines.push("  (none)");
+    }
+    lines.push("");
+    // Budgets
+    lines.push("Budgets:");
+    const skippedBudgets = r.budgets.filter((b) => b.skippedReason);
+    if (skippedBudgets.length > 0) {
+        for (const b of skippedBudgets) {
+            lines.push(`  - ${b.name}: skipped (${b.skippedReason})`);
+        }
+    }
+    else {
+        lines.push("  (all budgets importable)");
+    }
+    lines.push("");
+    // Collisions
+    lines.push("Collisions:");
+    if (r.collisions.length > 0) {
+        for (const c of r.collisions) {
+            if (c.action === "rename") {
+                lines.push(`  - ${c.kind} ${c.name} → ${c.newName} (renamed)`);
+            }
+            else {
+                lines.push(`  - ${c.kind} ${c.name} (${c.action})`);
+            }
+        }
+    }
+    else {
+        lines.push("  (none)");
+    }
+    lines.push("");
+    // Notes
+    lines.push("Notes:");
+    if (r.notes.length > 0) {
+        for (const note of r.notes) {
+            lines.push(`  - ${note}`);
+        }
+    }
+    else {
+        lines.push("  (none)");
+    }
+    lines.push("");
+    // Webhook secret notice (always shown)
+    lines.push("Webhook secrets will be regenerated and shown once at creation.");
+    return lines.join("\n");
+}