@productbrain/cli 0.1.0-beta.1 → 0.1.0-beta.102

package/dist/commands/admin/seed.js

@@ -0,0 +1,729 @@
+/**
+ * pb admin seed — workspace and platform seed operations (WP-312 S3, FEAT-970).
+ *
+ * Seed metadata is duplicated from `convex/admin/commandManifest.ts` for CLI help
+ * and ordering only — behavior is enforced server-side (STD-101).
+ */
+import * as clack from '@clack/prompts';
+import { adminCall } from '../../lib/client.js';
+import { resolveAdminConfig } from '../../lib/config.js';
+import { CLIError, ErrorCode } from '../../lib/errors.js';
+import { ask, confirm, intro, isInteractive, log, multiselect, note, outro } from '../../lib/prompts.js';
+import { readSession } from '../../lib/session.js';
+import { isJsonMode } from '../../lib/runner.js';
+import { confirmRiskNoteTitle, requiresAdminDestructiveConfirmation, seedAllConfirmMessage, seedMultiselectConfirmMessage, seedRunConfirmMessage, } from '../../lib/deployment.js';
+import { withSpinner } from '../../lib/spinner.js';
+import { adminBanner, bold, confirmProdAction, cyan, dim, green, heading, hint, icons, red, } from '../../lib/style.js';
+/**
+ * Order matches `ADMIN_COMMANDS` seed block in commandManifest.ts — dependency order for `seed all`.
+ */
+export const SEED_COMMAND_ENTRIES = [
+    {
+        name: 'seed:artifacts',
+        description: 'Seed Artifacts collection and related glossary entries (chainId, format, audience)',
+        requiresWorkspaceId: true,
+        dryRunSupported: false,
+    },
+    {
+        name: 'seed:chain-native-bet-constellation',
+        description: 'Seed the chain-native bet constellation for a workspace',
+        requiresWorkspaceId: false,
+        dryRunSupported: false,
+    },
+    {
+        name: 'seed:definitions-chain',
+        description: 'Seed the definitions chain collection',
+        requiresWorkspaceId: true,
+        dryRunSupported: false,
+    },
+    {
+        name: 'seed:domain-teams',
+        description: 'Seed domain teams collection entries',
+        requiresWorkspaceId: true,
+        dryRunSupported: true,
+    },
+    {
+        name: 'seed:features',
+        description: 'Seed Features collection and initial trust-audit entries',
+        requiresWorkspaceId: true,
+        dryRunSupported: false,
+    },
+    {
+        name: 'seed:hierarchy-tier1',
+        description: 'Apply Tier 1 hierarchy migrations (landscape thinkingLayer, key-results fields)',
+        requiresWorkspaceId: false,
+        dryRunSupported: true,
+    },
+    {
+        name: 'seed:id-prefixes',
+        description: 'Seed collection ID prefixes for a workspace',
+        requiresWorkspaceId: true,
+        dryRunSupported: false,
+    },
+    {
+        name: 'seed:knowledge',
+        description: 'Seed initial knowledge base (Standards, Features collections + labels)',
+        requiresWorkspaceId: true,
+        dryRunSupported: false,
+    },
+    {
+        name: 'seed:methodology-preset',
+        description: 'Install a methodology preset (e.g. cagan-tt) into a workspace — requires --preset-id',
+        requiresWorkspaceId: true,
+        dryRunSupported: false,
+    },
+    {
+        name: 'seed:process-templates',
+        description: 'Seed process templates collection for a workspace',
+        requiresWorkspaceId: true,
+        dryRunSupported: false,
+    },
+    {
+        name: 'seed:proposals',
+        description: 'Seed governance proposals collection',
+        requiresWorkspaceId: true,
+        dryRunSupported: false,
+    },
+    {
+        name: 'seed:readiness-config',
+        description: 'Migrate readiness config (readinessFloor, readinessWeight, readinessLayer) on all collections',
+        requiresWorkspaceId: false,
+        dryRunSupported: true,
+    },
+    {
+        name: 'seed:semantic-types-all',
+        description: 'Seed semantic types into all workspaces (cross-workspace action)',
+        requiresWorkspaceId: false,
+        dryRunSupported: false,
+    },
+    {
+        name: 'seed:migrate-scope-required-fields',
+        description: 'Fix scope semantic type: update requiredFields from description to purpose across all workspaces (TEN-346)',
+        requiresWorkspaceId: false,
+        dryRunSupported: true,
+    },
+    {
+        name: 'seed:writing-guidance',
+        description: 'Seed writing guidance entries for a workspace',
+        requiresWorkspaceId: true,
+        dryRunSupported: true,
+    },
+    // ─── WP-379 S5a: Starter Setup seed operations ─────────────────────────────
+    {
+        name: 'seed:show-starter',
+        description: 'List 18 Starter Setup assets for a workspace with body previews, lockLevel, and gate summary',
+        requiresWorkspaceId: true,
+        dryRunSupported: false,
+    },
+    {
+        name: 'seed:backfill-starter',
+        description: 'Idempotent bulk seed of Starter Setup bundle across workspaces. Defaults to dry-run.',
+        requiresWorkspaceId: false,
+        dryRunSupported: true,
+        dangerous: true,
+    },
+    {
+        name: 'seed:migrate-starter-fields',
+        description: 'STUB (WP-379 S5b): backfill explicit lockLevel + gate columns on existing setup-assets entries.',
+        requiresWorkspaceId: true,
+        dryRunSupported: true,
+    },
+];
+const SEED_BY_NAME = new Map(SEED_COMMAND_ENTRIES.map((e) => [e.name, e]));
+/** Manifest order for `pb admin seed all`. */
+export const SEED_MANIFEST_ORDER = SEED_COMMAND_ENTRIES.map((e) => e.name);
+function shortLabel(manifestName) {
+    return manifestName.startsWith('seed:') ? manifestName.slice('seed:'.length) : manifestName;
+}
+/** Accept `knowledge` or `seed:knowledge`. */
+export function normalizeSeedCommandName(input) {
+    const t = input.trim();
+    if (!t) {
+        throw new CLIError('Seed operation name is required.', {
+            code: ErrorCode.VALIDATION_FAILED,
+            category: 'validation',
+        });
+    }
+    const full = t.startsWith('seed:') ? t : `seed:${t}`;
+    if (!SEED_BY_NAME.has(full)) {
+        const known = SEED_MANIFEST_ORDER.map((n) => shortLabel(n)).join(', ');
+        throw new CLIError(`Unknown seed operation "${input}". Known short names: ${known}`, {
+            code: ErrorCode.VALIDATION_FAILED,
+            category: 'validation',
+        });
+    }
+    return full;
+}
+// ─── WP-379 S5a: Starter-specific arg builders ───────────────────────────────
+/**
+ * Build args for seed:backfill-starter with CLI-side validation.
+ *
+ * Rules:
+ *   - confirm:true requires workspaceScope to be explicitly provided
+ *   - dryRun defaults to true when confirm is false
+ *
+ * Exported for testing.
+ */
+export function buildBackfillStarterArgs(opts) {
+    const confirm = opts.confirm ?? false;
+    const dryRun = opts.dryRun ?? !confirm;
+    if (confirm && !opts.workspaceScope) {
+        throw new CLIError('backfill-starter: --workspace-scope (dev|prod|all) is required when --confirm is passed. ' +
+            'Specify which deployment scope to seed to prevent accidental cross-scope writes.', { code: ErrorCode.VALIDATION_FAILED, category: 'validation' });
+    }
+    const validScopes = ['dev', 'prod', 'all'];
+    if (opts.workspaceScope && !validScopes.includes(opts.workspaceScope)) {
+        throw new CLIError(`backfill-starter: --workspace-scope must be one of: ${validScopes.join(', ')}. Got: "${opts.workspaceScope}"`, { code: ErrorCode.VALIDATION_FAILED, category: 'validation' });
+    }
+    const args = { dryRun, confirm };
+    if (opts.workspaceScope)
+        args.workspaceScope = opts.workspaceScope;
+    return args;
+}
+function resolveWorkspaceId(explicit) {
+    if (explicit)
+        return explicit;
+    return readSession()?.workspaceId;
+}
+function requireWorkspaceId(explicit) {
+    const id = resolveWorkspaceId(explicit);
+    if (!id) {
+        throw new CLIError('Workspace id required — pass --workspace-id or run `pb session start` in this project.', { code: ErrorCode.VALIDATION_FAILED, category: 'validation' });
+    }
+    return id;
+}
+export function buildSeedArgs(manifestName, opts) {
+    const def = SEED_BY_NAME.get(manifestName);
+    if (!def) {
+        throw new CLIError(`Unknown seed command: ${manifestName}`, {
+            code: ErrorCode.VALIDATION_FAILED,
+            category: 'validation',
+        });
+    }
+    const args = {};
+    if (manifestName === 'seed:methodology-preset') {
+        const ws = requireWorkspaceId(opts.workspaceId);
+        if (!opts.presetId) {
+            throw new CLIError('seed:methodology-preset requires --preset-id <id>.', {
+                code: ErrorCode.VALIDATION_FAILED,
+                category: 'validation',
+            });
+        }
+        args.workspaceId = ws;
+        args.presetId = opts.presetId;
+        return args;
+    }
+    if (def.requiresWorkspaceId) {
+        args.workspaceId = requireWorkspaceId(opts.workspaceId);
+    }
+    else if (opts.workspaceId && manifestName === 'seed:chain-native-bet-constellation') {
+        args.workspaceId = opts.workspaceId;
+    }
+    if (def.dryRunSupported && opts.dryRun) {
+        args.dryRun = true;
+    }
+    return args;
+}
+function printSeedList() {
+    const rows = SEED_COMMAND_ENTRIES.map((e) => ({
+        name: shortLabel(e.name),
+        description: e.description,
+        workspace: e.requiresWorkspaceId ? 'yes' : 'no',
+        dryRun: e.dryRunSupported ? 'yes' : '—',
+    }));
+    if (isJsonMode()) {
+        process.stdout.write(JSON.stringify({ commands: rows }, null, 2) + '\n');
+        return;
+    }
+    try {
+        adminBanner(resolveAdminConfig().siteUrl);
+    }
+    catch { /* not configured */ }
+    const wName = Math.max(8, ...rows.map((r) => r.name.length));
+    const wWs = 9;
+    const wDr = 7;
+    process.stdout.write(`${bold('Name'.padEnd(wName))}  ${bold('Workspace'.padEnd(wWs))}  ${bold('Dry-run'.padEnd(wDr))}  ${bold('Description')}\n`);
+    process.stdout.write(dim('─'.repeat(wName + wWs + wDr + 40)) + '\n');
+    for (const r of rows) {
+        const dryRunStr = r.dryRun === 'yes' ? green(r.dryRun.padEnd(wDr)) : dim(r.dryRun.padEnd(wDr));
+        process.stdout.write(`${cyan(r.name.padEnd(wName))}  ${r.workspace.padEnd(wWs)}  ${dryRunStr}  ${dim(r.description)}\n`);
+    }
+    process.stdout.write('\n');
+    hint(`${SEED_COMMAND_ENTRIES.length} operations — behavior enforced server-side (commandManifest.ts)`);
+    hint('pb admin seed run <name>     Run one operation');
+    hint('pb admin seed all            Run all in manifest order');
+}
+async function printSeedStatus(workspaceIdOpt) {
+    const readiness = await adminCall('inspect:readiness-config', {});
+    let collection = null;
+    const wsId = resolveWorkspaceId(workspaceIdOpt);
+    if (wsId) {
+        collection = await adminCall('inspect:collection', { workspaceId: wsId });
+    }
+    const statusNote = 'Per-seed run history is not tracked server-side yet — use workspace totals and readiness diagnose as signals.';
+    if (isJsonMode()) {
+        process.stdout.write(JSON.stringify({
+            note: statusNote,
+            readinessConfig: readiness,
+            workspaceCollections: collection,
+            workspaceId: wsId ?? null,
+        }, null, 2) + '\n');
+        return;
+    }
+    process.stdout.write(`${bold('Seed status')}\n\n`);
+    process.stdout.write(`  ${dim(statusNote)}\n\n`);
+    process.stdout.write(`${bold('Readiness config migration (inspect:readiness-config)')}\n`);
+    process.stdout.write(`  ${dim(JSON.stringify(readiness, null, 2).split('\n').join('\n  '))}\n\n`);
+    if (collection && typeof collection === 'object' && collection !== null && 'workspace' in collection) {
+        const c = collection;
+        process.stdout.write(`${bold('Workspace')}\n`);
+        process.stdout.write(`  ${c.workspace.name} (${c.workspace.slug})\n`);
+        process.stdout.write(`  Collections: ${c.totalCollections} — Entries: ${c.totalEntries}\n\n`);
+    }
+    else if (!wsId) {
+        process.stdout.write(`${dim('No workspace id — pass --workspace-id or use an active session for collection breakdown.')}\n\n`);
+    }
+}
+async function runSeedOperation(manifestName, opts) {
+    const args = buildSeedArgs(manifestName, opts);
+    return adminCall(manifestName, args);
+}
+/** Attach seed subcommands to the `seed` Commander node. */
+export function attachSeedCommands(seed) {
+    // Default action when `pb admin seed` is invoked with no subcommand.
+    seed.action(async () => {
+        if (isJsonMode()) {
+            process.stdout.write(JSON.stringify({
+                operations: SEED_COMMAND_ENTRIES.map((e) => ({
+                    name: shortLabel(e.name),
+                    requiresWorkspaceId: e.requiresWorkspaceId,
+                    dryRunSupported: e.dryRunSupported,
+                    description: e.description,
+                })),
+            }, null, 2) + '\n');
+            return;
+        }
+        let siteUrl = '';
+        try {
+            siteUrl = resolveAdminConfig().siteUrl;
+        }
+        catch { /* not configured */ }
+        if (siteUrl)
+            adminBanner(siteUrl);
+        if (isInteractive()) {
+            intro('Seed Operations');
+            // methodology-preset needs --preset-id, not suitable for interactive menu
+            const menuEntries = SEED_COMMAND_ENTRIES.filter((e) => e.name !== 'seed:methodology-preset');
+            const selected = await multiselect({
+                message: 'Select operations to run (space to toggle, enter to confirm):',
+                options: menuEntries.map((e) => ({
+                    value: e.name,
+                    label: shortLabel(e.name),
+                    hint: [
+                        e.requiresWorkspaceId ? 'needs workspace' : 'platform-wide',
+                        e.dryRunSupported ? 'dry-run ✓' : '',
+                    ].filter(Boolean).join(' · '),
+                })),
+                required: false,
+            });
+            if (!Array.isArray(selected) || selected.length === 0) {
+                outro('Nothing selected — use pb admin seed run <name> for individual operations');
+                return;
+            }
+            // Resolve workspace-id upfront for any selected ops that need it
+            const needsWs = selected.some((name) => SEED_BY_NAME.get(name)?.requiresWorkspaceId);
+            let workspaceId;
+            if (needsWs) {
+                const sessionWsId = readSession()?.workspaceId;
+                if (sessionWsId) {
+                    workspaceId = sessionWsId;
+                    log.info(`Using session workspace: ${dim(sessionWsId)}`);
+                }
+                else {
+                    workspaceId = await ask({
+                        message: 'Workspace ID (required for selected operations):',
+                        validate: (v) => v.trim() ? undefined : 'Workspace ID is required',
+                    });
+                }
+            }
+            const needsConfirm = requiresAdminDestructiveConfirmation(siteUrl);
+            if (needsConfirm) {
+                const ok = await confirm({
+                    message: seedMultiselectConfirmMessage(siteUrl, selected.length),
+                    initialValue: false,
+                });
+                if (!ok) {
+                    outro('Cancelled');
+                    return;
+                }
+            }
+            // Run selected operations in order, stop on first failure (same policy as seed all)
+            const results = [];
+            for (const name of selected) {
+                try {
+                    await withSpinner(`Running ${shortLabel(name)}`, async () => {
+                        const args = buildSeedArgs(name, { workspaceId });
+                        await adminCall(name, args);
+                    });
+                    results.push({ name, ok: true });
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    results.push({ name, ok: false, error: msg });
+                    break;
+                }
+            }
+            const passed = results.filter((r) => r.ok).length;
+            const failed = results.filter((r) => !r.ok).length;
+            const summaryLines = results
+                .map((r) => r.ok ? `✓ ${shortLabel(r.name)}` : `✗ ${shortLabel(r.name)} — ${r.error}`)
+                .join('\n');
+            note(summaryLines, `${passed}/${selected.length} complete`);
+            if (failed > 0) {
+                process.exitCode = 1;
+                outro('Some operations failed — see above');
+            }
+            else {
+                outro(`${passed} operation(s) complete`);
+            }
+            return;
+        }
+        // Non-interactive (non-JSON) fallback — existing static preview
+        process.stdout.write(`${heading('Seed operations')}  ${dim(`(${SEED_COMMAND_ENTRIES.length})`)}\n\n`);
+        // Show first 6 entries as a preview
+        const preview = SEED_COMMAND_ENTRIES.slice(0, 6);
+        const wName = Math.max(...preview.map((e) => shortLabel(e.name).length));
+        for (const e of preview) {
+            const label = shortLabel(e.name);
+            const flags = e.dryRunSupported ? dim('  dry-run ✓') : '';
+            process.stdout.write(`  ${cyan(label.padEnd(wName))}  ${dim(e.description)}${flags}\n`);
+        }
+        if (SEED_COMMAND_ENTRIES.length > 6) {
+            process.stdout.write(`  ${dim(`... ${SEED_COMMAND_ENTRIES.length - 6} more — run pb admin seed list`)}\n`);
+        }
+        process.stdout.write('\n');
+        process.stdout.write(`  ${cyan('pb admin seed list')}             ${dim('Full list with workspace + dry-run flags')}\n`);
+        process.stdout.write(`  ${cyan('pb admin seed run <name>')}       ${dim('Run one operation')}\n`);
+        process.stdout.write(`  ${cyan('pb admin seed all')}              ${dim('Run all in manifest order')}\n`);
+        process.stdout.write(`  ${cyan('pb admin seed status')}           ${dim('Workspace readiness signals')}\n`);
+        process.stdout.write('\n');
+    });
+    seed
+        .command('list')
+        .description('List registered seed operations (names match server manifest)')
+        .action(() => {
+        printSeedList();
+    });
+    seed
+        .command('status')
+        .description('Readiness + workspace collection signals (no per-seed run log yet)')
+        .option('--workspace-id <id>', 'Workspace id (defaults to session workspace when set)')
+        .action(async (options) => {
+        if (!isJsonMode()) {
+            try {
+                adminBanner(resolveAdminConfig().siteUrl);
+            }
+            catch { /* not configured */ }
+            intro('Seed: status');
+        }
+        await printSeedStatus(options.workspaceId);
+        if (!isJsonMode()) {
+            outro('Read-only status check complete');
+        }
+    });
+    seed
+        .command('run')
+        .description('Run one seed operation by short or full manifest name')
+        .argument('<name>', 'e.g. knowledge or seed:knowledge')
+        .option('--dry-run', 'Pass dryRun when supported', false)
+        .option('--workspace-id <id>', 'Workspace id for workspace-scoped seeds')
+        .option('--preset-id <id>', 'Required for methodology-preset')
+        .option('--confirm', 'Non-interactive prod acknowledgment for dangerous ops', false)
+        .action(async (name, options) => {
+        const { siteUrl } = resolveAdminConfig();
+        const manifestName = normalizeSeedCommandName(name);
+        const meta = SEED_BY_NAME.get(manifestName);
+        const needsConfirm = requiresAdminDestructiveConfirmation(siteUrl);
+        // Remote / prod deployments require confirmation — not local or known dev-cloud.
+        if (needsConfirm) {
+            const ok = await confirmProdAction({
+                confirm: options.confirm,
+                isProduction: true,
+                message: seedRunConfirmMessage(siteUrl, manifestName),
+                noteTitle: confirmRiskNoteTitle(siteUrl),
+            });
+            if (!ok) {
+                process.stderr.write('Cancelled.\n');
+                process.exitCode = 1;
+                return;
+            }
+        }
+        if (!isJsonMode()) {
+            adminBanner(siteUrl);
+            intro(`seed:${shortLabel(manifestName)}`);
+        }
+        const data = await withSpinner(`Running ${manifestName}`, () => runSeedOperation(manifestName, {
+            workspaceId: options.workspaceId,
+            dryRun: options.dryRun,
+            presetId: options.presetId,
+        }));
+        if (isJsonMode()) {
+            process.stdout.write(JSON.stringify({ command: manifestName, data }, null, 2) + '\n');
+            return;
+        }
+        const summaryLines = data && typeof data === 'object'
+            ? Object.entries(data)
+                .map(([k, v]) => `${k}: ${typeof v === 'object' ? JSON.stringify(v) : String(v)}`)
+                .slice(0, 8)
+                .join('\n')
+            : String(data ?? 'No response data');
+        note(summaryLines || 'No response data', manifestName);
+        outro('Complete');
+    });
+    // ─── WP-379 S5a: Starter Setup subcommands ─────────────────────────────────
+    seed
+        .command('show-starter')
+        .description('List 18 Starter Setup assets for a workspace with body previews, lockLevel, and gate summary')
+        .option('--workspace-id <id>', 'Workspace id (required; defaults to session workspace when set)')
+        .action(async (options) => {
+        const wsId = requireWorkspaceId(options.workspaceId);
+        const { siteUrl } = resolveAdminConfig();
+        if (!isJsonMode()) {
+            adminBanner(siteUrl);
+            intro('seed:show-starter');
+        }
+        const data = await withSpinner('Fetching starter assets', () => adminCall('seed:show-starter', { workspaceId: wsId }));
+        if (isJsonMode()) {
+            process.stdout.write(JSON.stringify(data, null, 2) + '\n');
+            return;
+        }
+        const assets = Array.isArray(data?.assets) ? data.assets : [];
+        if (assets.length === 0) {
+            note('No platform-seeded assets found. Run: pb admin seed run backfill-starter', 'show-starter');
+            outro('Done');
+            return;
+        }
+        const wIdx = assets.length.toString().length + 2;
+        const wId = Math.max(10, ...assets.map((a) => a.entryId.length));
+        const wLock = 10;
+        const wGate = 24;
+        process.stdout.write(`${bold(`${'#'.padEnd(wIdx)}${' '}${'Entry ID'.padEnd(wId)}  ${'Lock'.padEnd(wLock)}  ${'Gate'.padEnd(wGate)}  Name / Preview`)}\n`);
+        process.stdout.write(dim('─'.repeat(wIdx + wId + wLock + wGate + 40)) + '\n');
+        assets.forEach((asset, i) => {
+            const idx = `${i + 1}.`.padEnd(wIdx);
+            const entryId = cyan(asset.entryId.padEnd(wId));
+            const lock = dim((asset.lockLevel ?? '—').padEnd(wLock));
+            const gateStr = asset.gate
+                ? asset.gate.kind === 'always'
+                    ? 'always'
+                    : `readiness[${asset.gate.min ?? '0'}–${asset.gate.max ?? '100'}]`
+                : '—';
+            const gate = dim(gateStr.padEnd(wGate));
+            const preview = dim(asset.bodyPreview.slice(0, 60));
+            process.stdout.write(`${idx} ${entryId}  ${lock}  ${gate}  ${bold(asset.name)}  ${preview}\n`);
+        });
+        process.stdout.write('\n');
+        note(`${assets.length} / 18 starter assets seeded`, 'show-starter');
+        outro('Done');
+    });
+    seed
+        .command('backfill-starter')
+        .description('Idempotent bulk seed of Starter Setup bundle across workspaces (dry-run by default)')
+        .option('--all', 'Required: acknowledge you intend to act on all workspaces in scope', false)
+        .option('--dry-run', 'Preview what would be seeded without writing anything (default behavior)', false)
+        .option('--workspace-scope <scope>', 'Required when --confirm is passed: dev | prod | all')
+        .option('--confirm', 'Execute seeds (requires --all and --workspace-scope)', false)
+        .action(async (options) => {
+        const { siteUrl } = resolveAdminConfig();
+        // CLI-side guard: --confirm requires --all
+        if (options.confirm && !options.all) {
+            process.stderr.write(red('Error: --confirm requires --all. Pass --all to acknowledge you intend to act on all workspaces in scope.\n'));
+            process.exitCode = 1;
+            return;
+        }
+        // Validate args and enforce scope gate via shared helper (also used by tests)
+        let callArgs;
+        try {
+            callArgs = buildBackfillStarterArgs({
+                confirm: options.confirm,
+                dryRun: options.dryRun,
+                workspaceScope: options.workspaceScope,
+            });
+        }
+        catch (e) {
+            process.stderr.write(red(`Error: ${e instanceof Error ? e.message : String(e)}\n`));
+            process.exitCode = 1;
+            return;
+        }
+        const isConfirm = options.confirm;
+        const isDryRun = callArgs.dryRun;
+        // Production acknowledgment for destructive confirm path
+        const needsConfirm = requiresAdminDestructiveConfirmation(siteUrl);
+        if (isConfirm && needsConfirm) {
+            const ok = await confirmProdAction({
+                confirm: options.confirm,
+                isProduction: true,
+                message: `Seed Starter Setup across ALL workspaces (scope: ${options.workspaceScope ?? 'all'}) on ${siteUrl}`,
+                noteTitle: confirmRiskNoteTitle(siteUrl),
+            });
+            if (!ok) {
+                process.stderr.write('Cancelled.\n');
+                process.exitCode = 1;
+                return;
+            }
+        }
+        if (!isJsonMode()) {
+            adminBanner(siteUrl);
+            intro(`seed:backfill-starter (${isDryRun ? 'DRY RUN' : 'EXECUTE'})`);
+        }
+        const result = await withSpinner(isDryRun ? 'Running dry-run scan' : 'Seeding workspaces', () => adminCall('seed:backfill-starter', callArgs));
+        if (isJsonMode()) {
+            process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+            return;
+        }
+        // Per-workspace progress
+        const rows = Array.isArray(result?.rows) ? result.rows : [];
+        for (const row of rows) {
+            const statusIcon = row.status === 'seeded' ? green(icons.pass) :
+                row.status === 'already-seeded' ? dim(icons.dot) :
+                    row.status === 'errored' ? red(icons.fail) :
+                        dim(icons.dot);
+            const detail = row.detail ? dim(`  ${row.detail}`) : '';
+            process.stdout.write(`  ${statusIcon}  ${bold(row.workspaceName)}${detail}\n`);
+        }
+        // Summary
+        const summaryLines = [
+            `Total workspaces: ${result.totalWorkspaces}`,
+            result.seededCount > 0 ? `${green(icons.pass)} Seeded: ${result.seededCount}` : null,
+            result.alreadySeededCount > 0 ? `${dim(icons.dot)} Already seeded: ${result.alreadySeededCount}` : null,
+            result.skippedCount > 0 ? `${dim(icons.dot)} Skipped (dry-run): ${result.skippedCount}` : null,
+            `Scope: ${result.workspaceScope}`,
+            result.dryRun ? dim('(dry-run — no writes performed)') : green('(writes executed)'),
+        ].filter(Boolean).join('\n');
+        note(summaryLines, 'backfill-starter');
+        outro('Done');
+    });
+    seed
+        .command('migrate-starter-fields')
+        .description('STUB (WP-379 S5b): backfill explicit lockLevel + gate columns on existing setup-assets entries')
+        .option('--workspace-id <id>', 'Workspace id (required; defaults to session workspace when set)')
+        .option('--dry-run', 'Preview changes without writing (default in stub)', false)
+        .action(async (options) => {
+        const wsId = requireWorkspaceId(options.workspaceId);
+        const { siteUrl } = resolveAdminConfig();
+        if (!isJsonMode()) {
+            adminBanner(siteUrl);
+            intro('seed:migrate-starter-fields');
+        }
+        const result = await withSpinner('Calling migrate-starter-fields', () => adminCall('seed:migrate-starter-fields', { workspaceId: wsId, dryRun: options.dryRun }));
+        if (isJsonMode()) {
+            process.stdout.write(JSON.stringify({ command: 'seed:migrate-starter-fields', data: result }, null, 2) + '\n');
+            return;
+        }
+        const summaryLines = [
+            `Migrated: ${result.migrated}`,
+            `Skipped: ${result.skipped}`,
+            `Dry-run: ${result.dryRun}`,
+            result.note ? dim(result.note) : null,
+        ].filter(Boolean).join('\n');
+        note(summaryLines, 'migrate-starter-fields');
+        outro('Done');
+    });
+    // ─── End WP-379 S5a Starter Setup subcommands ───────────────────────────────
+    seed
+        .command('all')
+        .description('Run all seed operations in manifest order (skips methodology-preset unless --preset-id)')
+        .option('--workspace-id <id>', 'Workspace id for workspace-scoped seeds')
+        .option('--preset-id <id>', 'If set, runs seed:methodology-preset with this preset')
+        .option('--dry-run', 'Pass dryRun to operations that support it', false)
+        .option('--confirm', 'Required in production (non-interactive)', false)
+        .action(async (options) => {
+        const { siteUrl } = resolveAdminConfig();
+        const needsConfirm = requiresAdminDestructiveConfirmation(siteUrl);
+        if (needsConfirm) {
+            const ok = await confirmProdAction({
+                confirm: options.confirm,
+                isProduction: true,
+                message: seedAllConfirmMessage(siteUrl),
+                noteTitle: confirmRiskNoteTitle(siteUrl),
+            });
+            if (!ok) {
+                process.stderr.write('Cancelled.\n');
+                process.exitCode = 1;
+                return;
+            }
+        }
+        const results = [];
+        // ── JSON mode: silent execution, structured output ────────────────────
+        if (isJsonMode()) {
+            for (const cmd of SEED_MANIFEST_ORDER) {
+                if (cmd === 'seed:methodology-preset' && !options.presetId) {
+                    results.push({ command: cmd, ok: true, skipped: true, note: 'pass --preset-id to include methodology preset' });
+                    continue;
+                }
+                try {
+                    const args = buildSeedArgs(cmd, { workspaceId: options.workspaceId, dryRun: options.dryRun, presetId: options.presetId });
+                    await adminCall(cmd, args);
+                    results.push({ command: cmd, ok: true });
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    results.push({ command: cmd, ok: false, error: msg });
+                    break;
+                }
+            }
+            if (results.some((r) => !r.ok))
+                process.exitCode = 1;
+            process.stdout.write(JSON.stringify({ results }, null, 2) + '\n');
+            return;
+        }
+        // ── Human mode: spinner per operation + finale summary panel ─────────
+        adminBanner(siteUrl);
+        intro('Seed All Operations');
+        const total = SEED_MANIFEST_ORDER.length;
+        let current = 0;
+        const startMs = Date.now();
+        const s = clack.spinner();
+        for (const cmd of SEED_MANIFEST_ORDER) {
+            current++;
+            const label = shortLabel(cmd);
+            if (cmd === 'seed:methodology-preset' && !options.presetId) {
+                results.push({ command: cmd, ok: true, skipped: true, note: 'pass --preset-id to include methodology preset' });
+                log.step(`${current}/${total} ${label} — skipped (no --preset-id)`);
+                continue;
+            }
+            s.start(`${current}/${total}  ${label}`);
+            try {
+                const args = buildSeedArgs(cmd, { workspaceId: options.workspaceId, dryRun: options.dryRun, presetId: options.presetId });
+                await adminCall(cmd, args);
+                s.stop(`${green(icons.pass)} ${label}`);
+                results.push({ command: cmd, ok: true });
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                s.stop(`${red(icons.fail)} ${label} — ${msg}`);
+                results.push({ command: cmd, ok: false, error: msg });
+                break;
+            }
+        }
+        const elapsed = ((Date.now() - startMs) / 1000).toFixed(1);
+        const passed = results.filter((r) => r.ok && !r.skipped).length;
+        const skippedCount = results.filter((r) => r.skipped).length;
+        const failed = results.filter((r) => !r.ok).length;
+        const summaryLines = [
+            `${green(icons.pass)} ${passed} succeeded`,
+            skippedCount > 0 ? `${dim(icons.dot)} ${skippedCount} skipped` : null,
+            failed > 0 ? `${red(icons.fail)} ${failed} failed` : null,
+            `${dim(`elapsed: ${elapsed}s`)}`,
+        ].filter(Boolean).join('\n');
+        note(summaryLines, `${passed + skippedCount}/${total} complete`);
+        if (failed > 0) {
+            process.exitCode = 1;
+            outro('Some operations failed — fix errors and re-run affected seeds individually');
+        }
+        else {
+            outro(`All ${passed} operations complete in ${elapsed}s`);
+        }
+    });
+}
+//# sourceMappingURL=seed.js.map