@ductape/cli 0.2.23 → 0.3.0

package/dist/commands/migration-environments.d.ts

@@ -0,0 +1,20 @@
+export declare function reconcileEnvironments(analysisPath: string, inventoryPath: string): {
+    ready: boolean;
+    detected: string[];
+    live: string[];
+    matched: string[];
+    missing: string[];
+    extra: string[];
+    ambiguous: {
+        normalized: string;
+        candidates: string[];
+    }[];
+    creation_supported: boolean;
+    creation_blocker: string;
+};
+export declare function runMigrationEnvironmentsReconcile(opts: {
+    analysis: string;
+    inventory: string;
+    strict?: boolean;
+    json?: boolean;
+}): void;

package/dist/commands/migration-environments.js

@@ -0,0 +1,58 @@
+import { printJson } from '../lib/output.js';
+import { readMigrationJson } from '../lib/migration-artifact.js';
+function read(file) {
+    return readMigrationJson(file);
+}
+function normalize(value) {
+    const v = value.toLowerCase();
+    if (['production', 'prod', 'prd'].includes(v))
+        return 'prd';
+    if (['staging', 'stage', 'stg'].includes(v))
+        return 'stg';
+    if (['sandbox', 'snd'].includes(v))
+        return 'snd';
+    if (['development', 'develop', 'dev'].includes(v))
+        return 'dev';
+    if (['testing', 'test'].includes(v))
+        return 'test';
+    return v;
+}
+function liveSlugs(inventory) {
+    const source = Array.isArray(inventory) ? inventory
+        : Array.isArray(inventory?.environments) ? inventory.environments
+            : Array.isArray(inventory?.data) ? inventory.data : [];
+    return source.map((item) => typeof item === 'string' ? item : item?.slug)
+        .filter((value) => typeof value === 'string');
+}
+export function reconcileEnvironments(analysisPath, inventoryPath) {
+    const analysis = read(analysisPath);
+    const detected = [...new Set((analysis.environments ?? []).map((value) => normalize(value)))];
+    const live = liveSlugs(read(inventoryPath));
+    const groups = new Map();
+    for (const slug of live)
+        groups.set(normalize(slug), [...(groups.get(normalize(slug)) ?? []), slug]);
+    const ambiguous = [...groups.entries()]
+        .filter(([, values]) => values.length > 1)
+        .map(([normalized, candidates]) => ({ normalized, candidates }));
+    const ambiguousNames = new Set(ambiguous.map((item) => item.normalized));
+    const matched = detected.filter((env) => groups.has(env) && !ambiguousNames.has(env));
+    const missing = detected.filter((env) => !groups.has(env));
+    const extra = [...groups.keys()].filter((env) => !detected.includes(env));
+    return {
+        ready: missing.length === 0 && ambiguous.length === 0,
+        detected,
+        live,
+        matched,
+        missing,
+        extra,
+        ambiguous,
+        creation_supported: false,
+        creation_blocker: 'The current administrative CLI exposes environment list/fetch only; create requires a platform route.',
+    };
+}
+export function runMigrationEnvironmentsReconcile(opts) {
+    const result = reconcileEnvironments(opts.analysis, opts.inventory);
+    printJson(result, Boolean(opts.json));
+    if (opts.strict && !result.ready)
+        throw new Error('Environment reconciliation is not ready.');
+}

package/dist/commands/migration-generated.d.ts

@@ -0,0 +1,68 @@
+type ContractKind = 'public_api' | 'generated_client' | 'schema' | 'ui_snapshot' | 'internal';
+interface GeneratedManifest {
+    version: 1;
+    artifact_kind: 'ductape_migration_generated_vendor_evidence';
+    source: string;
+    analysis: string;
+    generated: Array<{
+        file: string;
+        checked_in_checksum: string;
+        contract_kind: ContractKind;
+        generator: {
+            name: string;
+            version: string;
+            command: string;
+            inputs: Array<{
+                file: string;
+                checksum: string;
+            }>;
+        };
+        regeneration: {
+            clean_workspace: true;
+            status: 'passed';
+            evidence: string[];
+            regenerated_checksum: string;
+            matches_checked_in: boolean;
+        };
+        compatibility_tests: string[];
+        owner: string;
+    }>;
+    vendor: Array<{
+        file: string;
+        current_checksum: string;
+        upstream_source: string;
+        upstream_version: string;
+        upstream_checksum: string;
+        owner: string;
+        locally_modified: boolean;
+        diff_evidence: string[];
+        compatibility_tests: string[];
+    }>;
+}
+export declare function initializeMigrationGenerated(opts: {
+    analysis: string;
+    definition: string;
+    output?: string;
+}): {
+    path: string;
+    manifest: GeneratedManifest;
+};
+export declare function validateMigrationGenerated(file: string): {
+    evidence: string;
+    ready: boolean;
+    generated: number;
+    vendor: number;
+    blockers: string[];
+};
+export declare function runMigrationGeneratedInit(opts: {
+    analysis: string;
+    definition: string;
+    output?: string;
+    json?: boolean;
+}): void;
+export declare function runMigrationGeneratedValidate(opts: {
+    file: string;
+    strict?: boolean;
+    json?: boolean;
+}): void;
+export {};

package/dist/commands/migration-generated.js

@@ -0,0 +1,217 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { printJson } from '../lib/output.js';
+import { readMigrationJson, writeMigrationJson } from '../lib/migration-artifact.js';
+function readJson(file) {
+    return readMigrationJson(file);
+}
+function checksum(file) {
+    return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+function nonEmpty(values) {
+    return Array.isArray(values) && values.length > 0 &&
+        values.every((value) => typeof value === 'string' && value.trim().length > 0);
+}
+function sourceFile(source, file) {
+    if (!file || path.isAbsolute(file))
+        throw new Error(`Repository file must be relative: ${file}`);
+    const normalized = path.normalize(file).replaceAll('\\', '/');
+    if (normalized === '..' || normalized.startsWith('../')) {
+        throw new Error(`Repository file escapes the source root: ${file}`);
+    }
+    const absolute = path.resolve(source, normalized);
+    if (!fs.existsSync(absolute) || !fs.statSync(absolute).isFile()) {
+        throw new Error(`Repository file does not exist: ${normalized}`);
+    }
+    return { file: normalized, absolute };
+}
+function exactKeys(entries, label) {
+    const keys = entries.map((entry) => entry.file);
+    if (new Set(keys).size !== keys.length)
+        throw new Error(`${label} contains duplicate file classifications.`);
+}
+export function initializeMigrationGenerated(opts) {
+    const analysisPath = path.resolve(opts.analysis);
+    const analysis = readJson(analysisPath);
+    const source = path.resolve(analysis.source);
+    const definition = readJson(path.resolve(opts.definition));
+    if (!Array.isArray(definition.generated) || !Array.isArray(definition.vendor)) {
+        throw new Error('Definition requires generated and vendor arrays.');
+    }
+    exactKeys(definition.generated, 'generated');
+    exactKeys(definition.vendor, 'vendor');
+    const hintFiles = new Set((analysis.generated_source_hints ?? []).map((hint) => hint.file));
+    const classified = new Set(definition.generated.map((entry) => entry.file));
+    const missingHints = [...hintFiles].filter((file) => !classified.has(file));
+    if (missingHints.length) {
+        throw new Error(`Generated hints require contextual classification: ${missingHints.join(', ')}`);
+    }
+    const manifest = {
+        version: 1,
+        artifact_kind: 'ductape_migration_generated_vendor_evidence',
+        source,
+        analysis: analysisPath,
+        generated: definition.generated.map((entry) => {
+            const checkedIn = sourceFile(source, entry.file);
+            if (!['public_api', 'generated_client', 'schema', 'ui_snapshot', 'internal'].includes(entry.contract_kind)) {
+                throw new Error(`${entry.file}: invalid contract_kind.`);
+            }
+            if (!entry.generator?.name?.trim() || !entry.generator.version?.trim() ||
+                !entry.generator.command?.trim() || !nonEmpty(entry.generator.inputs)) {
+                throw new Error(`${entry.file}: generator name, version, command, and inputs are required.`);
+            }
+            if (!entry.owner?.trim())
+                throw new Error(`${entry.file}: owner is required.`);
+            if (entry.regeneration?.clean_workspace !== true || entry.regeneration.status !== 'passed' ||
+                !nonEmpty(entry.regeneration.evidence) || !entry.regeneration.regenerated_output?.trim()) {
+                throw new Error(`${entry.file}: passing clean-workspace regeneration evidence is required.`);
+            }
+            const regenerated = path.resolve(entry.regeneration.regenerated_output);
+            if (!fs.existsSync(regenerated) || !fs.statSync(regenerated).isFile()) {
+                throw new Error(`${entry.file}: regenerated_output does not exist.`);
+            }
+            const checkedInChecksum = checksum(checkedIn.absolute);
+            const regeneratedChecksum = checksum(regenerated);
+            const requiresContract = entry.contract_kind !== 'internal';
+            if (requiresContract && !nonEmpty(entry.compatibility_tests)) {
+                throw new Error(`${entry.file}: ${entry.contract_kind} requires compatibility tests.`);
+            }
+            return {
+                file: checkedIn.file,
+                checked_in_checksum: checkedInChecksum,
+                contract_kind: entry.contract_kind,
+                generator: {
+                    name: entry.generator.name,
+                    version: entry.generator.version,
+                    command: entry.generator.command,
+                    inputs: entry.generator.inputs.map((input) => {
+                        const resolved = sourceFile(source, input);
+                        return { file: resolved.file, checksum: checksum(resolved.absolute) };
+                    }),
+                },
+                regeneration: {
+                    clean_workspace: true,
+                    status: 'passed',
+                    evidence: entry.regeneration.evidence,
+                    regenerated_checksum: regeneratedChecksum,
+                    matches_checked_in: regeneratedChecksum === checkedInChecksum,
+                },
+                compatibility_tests: entry.compatibility_tests ?? [],
+                owner: entry.owner,
+            };
+        }),
+        vendor: definition.vendor.map((entry) => {
+            const current = sourceFile(source, entry.file);
+            if (!entry.upstream_source?.trim() || !entry.upstream_version?.trim() ||
+                !/^[a-f0-9]{64}$/.test(entry.upstream_checksum) || !entry.owner?.trim()) {
+                throw new Error(`${entry.file}: upstream source, version, SHA-256 checksum, and owner are required.`);
+            }
+            const currentChecksum = checksum(current.absolute);
+            const actuallyModified = currentChecksum !== entry.upstream_checksum;
+            if (entry.locally_modified !== actuallyModified) {
+                throw new Error(`${entry.file}: locally_modified does not match the upstream checksum comparison.`);
+            }
+            if (actuallyModified && !nonEmpty(entry.diff_evidence)) {
+                throw new Error(`${entry.file}: locally modified vendor source requires diff evidence.`);
+            }
+            return {
+                ...entry,
+                file: current.file,
+                current_checksum: currentChecksum,
+                diff_evidence: entry.diff_evidence ?? [],
+                compatibility_tests: entry.compatibility_tests ?? [],
+            };
+        }),
+    };
+    const output = path.resolve(opts.output ??
+        path.join(path.dirname(analysisPath), 'generated-vendor-evidence.json'));
+    if (fs.existsSync(output))
+        throw new Error(`Generated/vendor evidence already exists: ${output}`);
+    fs.mkdirSync(path.dirname(output), { recursive: true });
+    writeMigrationJson(output, manifest, { createOnly: true });
+    return { path: output, manifest };
+}
+export function validateMigrationGenerated(file) {
+    const resolved = path.resolve(file);
+    const manifest = readJson(resolved);
+    if (manifest.artifact_kind !== 'ductape_migration_generated_vendor_evidence') {
+        throw new Error('Invalid generated/vendor migration evidence.');
+    }
+    const blockers = [];
+    for (const entry of manifest.generated ?? []) {
+        try {
+            const current = sourceFile(manifest.source, entry.file);
+            if (checksum(current.absolute) !== entry.checked_in_checksum) {
+                blockers.push(`${entry.file}: checked-in generated output changed`);
+            }
+        }
+        catch {
+            blockers.push(`${entry.file}: checked-in generated output is missing`);
+        }
+        for (const input of entry.generator?.inputs ?? []) {
+            try {
+                if (checksum(sourceFile(manifest.source, input.file).absolute) !== input.checksum) {
+                    blockers.push(`${entry.file}: generator input changed: ${input.file}`);
+                }
+            }
+            catch {
+                blockers.push(`${entry.file}: generator input is missing: ${input.file}`);
+            }
+        }
+        if (!entry.generator?.version?.trim())
+            blockers.push(`${entry.file}: generator version is missing`);
+        if (!entry.regeneration?.clean_workspace || entry.regeneration.status !== 'passed' ||
+            !entry.regeneration.evidence?.length) {
+            blockers.push(`${entry.file}: clean regeneration evidence is incomplete`);
+        }
+        if (!entry.regeneration?.matches_checked_in ||
+            entry.regeneration.regenerated_checksum !== entry.checked_in_checksum) {
+            blockers.push(`${entry.file}: regenerated output differs from checked-in output`);
+        }
+        if (entry.contract_kind !== 'internal' && !entry.compatibility_tests?.length) {
+            blockers.push(`${entry.file}: contract compatibility tests are missing`);
+        }
+    }
+    for (const entry of manifest.vendor ?? []) {
+        let currentChecksum;
+        try {
+            const current = sourceFile(manifest.source, entry.file);
+            currentChecksum = checksum(current.absolute);
+        }
+        catch {
+            blockers.push(`${entry.file}: vendored source is missing`);
+            continue;
+        }
+        if (currentChecksum !== entry.current_checksum)
+            blockers.push(`${entry.file}: vendored source changed after review`);
+        const actuallyModified = currentChecksum !== entry.upstream_checksum;
+        if (actuallyModified !== entry.locally_modified)
+            blockers.push(`${entry.file}: vendor modification classification is stale`);
+        if (actuallyModified && (!entry.owner?.trim() || !entry.diff_evidence?.length)) {
+            blockers.push(`${entry.file}: local vendor modification lacks owner or diff evidence`);
+        }
+    }
+    return {
+        evidence: resolved,
+        ready: blockers.length === 0,
+        generated: manifest.generated?.length ?? 0,
+        vendor: manifest.vendor?.length ?? 0,
+        blockers,
+    };
+}
+export function runMigrationGeneratedInit(opts) {
+    const result = initializeMigrationGenerated(opts);
+    printJson({
+        path: result.path,
+        generated: result.manifest.generated.length,
+        vendor: result.manifest.vendor.length,
+    }, Boolean(opts.json));
+}
+export function runMigrationGeneratedValidate(opts) {
+    const result = validateMigrationGenerated(opts.file);
+    printJson(result, Boolean(opts.json));
+    if (opts.strict && !result.ready) {
+        throw new Error('Generated/vendor evidence is not ready: resolve every reported blocker.');
+    }
+}

package/dist/commands/migration-portfolio.d.ts

@@ -0,0 +1,88 @@
+interface PartitionProposal {
+    version: 1;
+    artifact_kind: 'ductape_migration_partition_proposal';
+    authority: 'advisory_only';
+    ledger: string;
+    limits: {
+        max_bytes: number;
+        max_tokens: number;
+        token_estimate: 'ceil(bytes/4)';
+    };
+    partitions: Array<{
+        tag: string;
+        files: string[];
+        dependencies: string[];
+        byte_estimate: number;
+        token_estimate: number;
+        oversized_scc: boolean;
+    }>;
+}
+interface Portfolio {
+    version: 1;
+    artifact_kind: 'ductape_migration_portfolio';
+    ledger: string;
+    partitions: Array<{
+        tag: string;
+        files: string[];
+        context_budget: number;
+        summary: string;
+        provenance: Array<{
+            file: string;
+            checksum: string;
+        }>;
+    }>;
+    slices: string[];
+    cross_slice_contracts: Array<{
+        provider: string;
+        consumer: string;
+        contract: string;
+        evidence: string;
+    }>;
+}
+export declare function proposeMigrationPartitions(opts: {
+    ledger: string;
+    maxBytes?: number;
+    maxTokens?: number;
+    output?: string;
+}): {
+    path: string;
+    proposal: PartitionProposal;
+};
+export declare function initializeMigrationPortfolio(opts: {
+    ledger: string;
+    definition: string;
+    output?: string;
+}): {
+    path: string;
+    portfolio: Portfolio;
+};
+export declare function validateMigrationPortfolio(portfolioPath: string): {
+    portfolio: string;
+    ready: boolean;
+    partitions: number;
+    slices: number;
+    coverage: {
+        reviewed_files: number;
+        partitioned_files: number;
+    };
+    blockers: string[];
+};
+export declare function runMigrationPortfolioInit(opts: {
+    ledger: string;
+    definition: string;
+    output?: string;
+    json?: boolean;
+}): void;
+export declare function runMigrationPortfolioValidate(opts: {
+    portfolio: string;
+    strict?: boolean;
+    json?: boolean;
+}): void;
+export declare function runMigrationPortfolioPropose(opts: {
+    ledger: string;
+    maxBytes?: number;
+    maxTokens?: number;
+    output?: string;
+    json?: boolean;
+}): void;
+export {};

package/dist/commands/migration-portfolio.js

@@ -0,0 +1,223 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { printJson } from '../lib/output.js';
+import { validateMigrationSlice } from './migration-slice.js';
+import { readMigrationJson, writeMigrationJson } from '../lib/migration-artifact.js';
+function read(file) {
+    return readMigrationJson(file);
+}
+function digest(file) {
+    try {
+        return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+    }
+    catch {
+        return null;
+    }
+}
+export function proposeMigrationPartitions(opts) {
+    const ledgerPath = path.resolve(opts.ledger);
+    const ledger = read(ledgerPath);
+    const maxBytes = opts.maxBytes ?? 128_000;
+    const maxTokens = opts.maxTokens ?? 32_000;
+    if (!Number.isInteger(maxBytes) || maxBytes <= 0 || !Number.isInteger(maxTokens) || maxTokens <= 0) {
+        throw new Error('Partition byte and token limits must be positive integers.');
+    }
+    const known = new Set(ledger.entries.map((entry) => entry.file));
+    const graph = new Map(ledger.entries.map((entry) => [
+        entry.file,
+        [
+            ...(entry.references ?? []).filter((reference) => !reference.external).map((reference) => reference.target),
+            ...(entry.follow_up_files ?? []),
+        ].filter((target) => known.has(target)),
+    ]));
+    let nextIndex = 0;
+    const stack = [];
+    const onStack = new Set();
+    const indices = new Map();
+    const low = new Map();
+    const components = [];
+    const visit = (node) => {
+        indices.set(node, nextIndex);
+        low.set(node, nextIndex++);
+        stack.push(node);
+        onStack.add(node);
+        for (const dependency of graph.get(node) ?? []) {
+            if (!indices.has(dependency)) {
+                visit(dependency);
+                low.set(node, Math.min(low.get(node), low.get(dependency)));
+            }
+            else if (onStack.has(dependency)) {
+                low.set(node, Math.min(low.get(node), indices.get(dependency)));
+            }
+        }
+        if (low.get(node) === indices.get(node)) {
+            const component = [];
+            let current;
+            do {
+                current = stack.pop();
+                onStack.delete(current);
+                component.push(current);
+            } while (current !== node);
+            components.push(component.sort());
+        }
+    };
+    for (const entry of ledger.entries)
+        if (!indices.has(entry.file))
+            visit(entry.file);
+    const componentFor = new Map();
+    components.forEach((files, component) => files.forEach((file) => componentFor.set(file, component)));
+    const componentDependencies = components.map(() => new Set());
+    for (const [file, dependencies] of graph) {
+        const owner = componentFor.get(file);
+        for (const dependencyFile of dependencies) {
+            const dependency = componentFor.get(dependencyFile);
+            if (owner !== dependency)
+                componentDependencies[owner].add(dependency);
+        }
+    }
+    const ordered = [];
+    const seen = new Set();
+    const add = (component) => {
+        if (seen.has(component))
+            return;
+        seen.add(component);
+        componentDependencies[component].forEach(add);
+        ordered.push(component);
+    };
+    components.forEach((_, component) => add(component));
+    const tags = new Map(ordered.map((component, position) => [component, `partition-${position + 1}`]));
+    const partitions = ordered.map((component) => {
+        const files = components[component];
+        const byteEstimate = files.reduce((sum, file) => {
+            try {
+                return sum + fs.statSync(path.join(ledger.source, file)).size;
+            }
+            catch {
+                return sum;
+            }
+        }, 0);
+        const tokenEstimate = Math.ceil(byteEstimate / 4);
+        return {
+            tag: tags.get(component),
+            files,
+            dependencies: [...componentDependencies[component]].map((dependency) => tags.get(dependency)),
+            byte_estimate: byteEstimate,
+            token_estimate: tokenEstimate,
+            oversized_scc: byteEstimate > maxBytes || tokenEstimate > maxTokens,
+        };
+    });
+    const proposal = {
+        version: 1,
+        artifact_kind: 'ductape_migration_partition_proposal',
+        authority: 'advisory_only',
+        ledger: ledgerPath,
+        limits: { max_bytes: maxBytes, max_tokens: maxTokens, token_estimate: 'ceil(bytes/4)' },
+        partitions,
+    };
+    const output = path.resolve(opts.output ?? path.join(path.dirname(ledgerPath), 'partition-proposal.json'));
+    writeMigrationJson(output, proposal);
+    return { path: output, proposal };
+}
+export function initializeMigrationPortfolio(opts) {
+    const ledgerPath = path.resolve(opts.ledger);
+    const definition = read(path.resolve(opts.definition));
+    if (!Array.isArray(definition.partitions) || !Array.isArray(definition.slices) ||
+        !Array.isArray(definition.cross_slice_contracts)) {
+        throw new Error('Portfolio definition requires partitions, slices, and cross_slice_contracts arrays.');
+    }
+    const output = path.resolve(opts.output ?? path.join(path.dirname(ledgerPath), 'portfolio.json'));
+    if (fs.existsSync(output))
+        throw new Error(`Migration portfolio already exists: ${output}`);
+    const portfolio = {
+        version: 1,
+        artifact_kind: 'ductape_migration_portfolio',
+        ledger: ledgerPath,
+        ...definition,
+        partitions: definition.partitions.map((partition) => ({
+            ...partition,
+            provenance: partition.files.map((file) => ({
+                file,
+                checksum: digest(path.join(read(ledgerPath).source, file)) ?? '',
+            })),
+        })),
+        slices: definition.slices.map((slice) => path.resolve(slice)),
+    };
+    writeMigrationJson(output, portfolio, { createOnly: true });
+    return { path: output, portfolio };
+}
+export function validateMigrationPortfolio(portfolioPath) {
+    const resolved = path.resolve(portfolioPath);
+    const portfolio = read(resolved);
+    if (portfolio.artifact_kind !== 'ductape_migration_portfolio')
+        throw new Error('Invalid migration portfolio.');
+    const ledger = read(portfolio.ledger);
+    const blockers = [];
+    const coverage = new Map();
+    for (const partition of portfolio.partitions) {
+        if (!partition.tag || partition.context_budget <= 0 || !partition.summary.trim()) {
+            blockers.push(`partition ${partition.tag || '<unknown>'}: tag, positive context_budget, and summary are required`);
+        }
+        const provenance = new Map(partition.provenance.map((item) => [item.file, item.checksum]));
+        for (const file of partition.files) {
+            coverage.set(file, (coverage.get(file) ?? 0) + 1);
+            const recorded = provenance.get(file);
+            if (!recorded || digest(path.join(ledger.source, file)) !== recorded) {
+                blockers.push(`partition ${partition.tag}: stale or missing provenance for ${file}`);
+            }
+        }
+    }
+    for (const entry of ledger.entries) {
+        if (!coverage.has(entry.file))
+            blockers.push(`portfolio coverage missing: ${entry.file}`);
+    }
+    for (const [file, count] of coverage) {
+        if (!ledger.entries.some((entry) => entry.file === file))
+            blockers.push(`partition references unknown file: ${file}`);
+        if (count > 1)
+            blockers.push(`file appears in multiple partitions: ${file}`);
+    }
+    const sliceTags = new Set();
+    if (portfolio.slices.length === 0)
+        blockers.push('portfolio must contain at least one migration slice');
+    for (const slicePath of portfolio.slices) {
+        const result = validateMigrationSlice(slicePath);
+        sliceTags.add(result.tag);
+        if (!result.ready)
+            blockers.push(`slice ${result.tag}: ${result.blockers.join('; ')}`);
+    }
+    for (const contract of portfolio.cross_slice_contracts) {
+        if (!sliceTags.has(contract.provider) || !sliceTags.has(contract.consumer) ||
+            !contract.contract || !contract.evidence) {
+            blockers.push(`cross-slice contract ${contract.provider} -> ${contract.consumer} is incomplete`);
+        }
+    }
+    return {
+        portfolio: resolved,
+        ready: blockers.length === 0,
+        partitions: portfolio.partitions.length,
+        slices: portfolio.slices.length,
+        coverage: { reviewed_files: ledger.entries.length, partitioned_files: coverage.size },
+        blockers,
+    };
+}
+export function runMigrationPortfolioInit(opts) {
+    const result = initializeMigrationPortfolio(opts);
+    printJson({ path: result.path, partitions: result.portfolio.partitions.length }, Boolean(opts.json));
+}
+export function runMigrationPortfolioValidate(opts) {
+    const result = validateMigrationPortfolio(opts.portfolio);
+    printJson(result, Boolean(opts.json));
+    if (opts.strict && !result.ready) {
+        throw new Error('Migration portfolio is not ready: resolve every partition, slice, and contract blocker.');
+    }
+}
+export function runMigrationPortfolioPropose(opts) {
+    const result = proposeMigrationPartitions(opts);
+    printJson({
+        path: result.path,
+        authority: result.proposal.authority,
+        partitions: result.proposal.partitions.length,
+        oversized_sccs: result.proposal.partitions.filter((partition) => partition.oversized_scc).length,
+    }, Boolean(opts.json));
+}