@ductape/cli 0.2.23 → 0.3.1

package/dist/commands/migration-e2e.js

@@ -0,0 +1,189 @@
+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 relativeFile(source, file) {
+    if (!file || path.isAbsolute(file))
+        throw new Error(`E2E suite file must be repository-relative: ${file}`);
+    const normalized = path.normalize(file).replaceAll('\\', '/');
+    if (normalized === '..' || normalized.startsWith('../')) {
+        throw new Error(`E2E suite file escapes the source repository: ${file}`);
+    }
+    const resolved = path.resolve(source, normalized);
+    if (!fs.statSync(resolved).isFile())
+        throw new Error(`E2E suite file does not exist: ${normalized}`);
+    return normalized;
+}
+function requireEvidence(value, label) {
+    if (!value.command?.trim())
+        throw new Error(`${label} command is required.`);
+    if (value.status !== 'passed')
+        throw new Error(`${label} must have passed before it can be recorded.`);
+    if (!value.environment?.trim())
+        throw new Error(`${label} environment evidence is required.`);
+    if (!Array.isArray(value.evidence) || value.evidence.length === 0 ||
+        value.evidence.some((item) => !item?.trim())) {
+        throw new Error(`${label} requires at least one non-empty evidence entry.`);
+    }
+}
+export function initializeMigrationE2E(opts) {
+    const source = path.resolve(opts.source);
+    if (!fs.statSync(source).isDirectory())
+        throw new Error(`Migration source is not a directory: ${source}`);
+    const definition = readJson(path.resolve(opts.definition));
+    requireEvidence({ command: definition.command, ...definition.baseline }, 'Baseline E2E run');
+    if (!Array.isArray(definition.suite_files) || definition.suite_files.length === 0) {
+        throw new Error('Baseline E2E suite_files must contain at least one test or fixture.');
+    }
+    const files = [...new Set(definition.suite_files.map((file) => relativeFile(source, file)))].sort();
+    if (files.length !== definition.suite_files.length)
+        throw new Error('Baseline E2E suite_files contains duplicates.');
+    const output = path.resolve(opts.output ?? path.join(source, 'ductape', 'migration-guidance', 'e2e-baseline.json'));
+    if (fs.existsSync(output))
+        throw new Error(`Migration E2E baseline already exists: ${output}`);
+    const manifest = {
+        version: 1,
+        artifact_kind: 'ductape_migration_e2e_baseline',
+        source,
+        created_at: new Date().toISOString(),
+        command: definition.command,
+        suite: files.map((file) => ({ file, checksum: checksum(path.join(source, file)) })),
+        baseline: definition.baseline,
+        final: null,
+    };
+    fs.mkdirSync(path.dirname(output), { recursive: true });
+    writeMigrationJson(output, manifest, { createOnly: true });
+    return { path: output, manifest };
+}
+export function recordMigrationE2EFinal(manifestFile, evidenceFile) {
+    const resolved = path.resolve(manifestFile);
+    const manifest = readJson(resolved);
+    if (manifest.artifact_kind !== 'ductape_migration_e2e_baseline') {
+        throw new Error('Invalid migration E2E baseline manifest.');
+    }
+    if (manifest.final)
+        throw new Error('Final E2E evidence is already recorded.');
+    const evidence = readJson(path.resolve(evidenceFile));
+    requireEvidence(evidence, 'Final E2E run');
+    if (evidence.command !== manifest.command) {
+        throw new Error('Final E2E command must exactly match the original baseline command.');
+    }
+    if (!evidence.suite_root?.trim() || !path.isAbsolute(evidence.suite_root) ||
+        !fs.existsSync(evidence.suite_root) || !fs.statSync(evidence.suite_root).isDirectory()) {
+        throw new Error('Final E2E suite_root must be an existing absolute migrated-codebase directory.');
+    }
+    const changed = manifest.suite.filter(({ file, checksum: expected }) => {
+        try {
+            return checksum(path.join(manifest.source, file)) !== expected;
+        }
+        catch {
+            return true;
+        }
+    });
+    if (changed.length) {
+        throw new Error(`Original E2E baseline changed or is missing: ${changed.map((item) => item.file).join(', ')}`);
+    }
+    const migratedMismatch = manifest.suite.filter(({ file, checksum: expected }) => {
+        try {
+            return checksum(path.join(evidence.suite_root, file)) !== expected;
+        }
+        catch {
+            return true;
+        }
+    });
+    if (migratedMismatch.length) {
+        throw new Error(`Migrated codebase is not using the original E2E suite: ${migratedMismatch.map((item) => item.file).join(', ')}`);
+    }
+    manifest.final = { ...evidence, recorded_at: new Date().toISOString() };
+    writeMigrationJson(resolved, manifest, { backup: true });
+    return manifest;
+}
+export function validateMigrationE2E(manifestFile) {
+    const resolved = path.resolve(manifestFile);
+    const manifest = readJson(resolved);
+    if (manifest.artifact_kind !== 'ductape_migration_e2e_baseline') {
+        throw new Error('Invalid migration E2E baseline manifest.');
+    }
+    const blockers = [];
+    if (!manifest.suite?.length)
+        blockers.push('original E2E suite is empty');
+    for (const item of manifest.suite ?? []) {
+        try {
+            if (checksum(path.join(manifest.source, item.file)) !== item.checksum) {
+                blockers.push(`${item.file}: original baseline checksum changed`);
+            }
+        }
+        catch {
+            blockers.push(`${item.file}: original baseline file is missing`);
+        }
+    }
+    if (manifest.baseline?.status !== 'passed' || !manifest.baseline.evidence?.length) {
+        blockers.push('passing baseline E2E evidence is missing');
+    }
+    if (!manifest.final)
+        blockers.push('final run against the original E2E suite is missing');
+    else {
+        if (manifest.final.command !== manifest.command)
+            blockers.push('final command differs from baseline command');
+        if (manifest.final.status !== 'passed' || !manifest.final.evidence?.length) {
+            blockers.push('passing final E2E evidence is missing');
+        }
+        for (const item of manifest.suite ?? []) {
+            try {
+                if (checksum(path.join(manifest.final.suite_root, item.file)) !== item.checksum) {
+                    blockers.push(`${item.file}: migrated suite differs from original baseline`);
+                }
+            }
+            catch {
+                blockers.push(`${item.file}: migrated suite file is missing`);
+            }
+        }
+    }
+    return { manifest: resolved, ready: blockers.length === 0, suite_files: manifest.suite?.length ?? 0, blockers };
+}
+export function validateMigrationE2EBaseline(manifestFile) {
+    const resolved = path.resolve(manifestFile);
+    const manifest = readJson(resolved);
+    if (manifest.artifact_kind !== 'ductape_migration_e2e_baseline') {
+        throw new Error('Invalid migration E2E baseline manifest.');
+    }
+    const blockers = [];
+    if (!manifest.suite?.length)
+        blockers.push('original E2E suite is empty');
+    for (const item of manifest.suite ?? []) {
+        try {
+            if (checksum(path.join(manifest.source, item.file)) !== item.checksum) {
+                blockers.push(`${item.file}: original baseline checksum changed`);
+            }
+        }
+        catch {
+            blockers.push(`${item.file}: original baseline file is missing`);
+        }
+    }
+    if (manifest.baseline?.status !== 'passed' || !manifest.baseline.evidence?.length) {
+        blockers.push('passing baseline E2E evidence is missing');
+    }
+    return { manifest: resolved, ready: blockers.length === 0, blockers };
+}
+export function runMigrationE2EInit(opts) {
+    const result = initializeMigrationE2E(opts);
+    printJson({ path: result.path, suite_files: result.manifest.suite.length }, Boolean(opts.json));
+}
+export function runMigrationE2EFinal(opts) {
+    const manifest = recordMigrationE2EFinal(opts.manifest, opts.evidence);
+    printJson({ manifest: path.resolve(opts.manifest), final_status: manifest.final?.status }, Boolean(opts.json));
+}
+export function runMigrationE2EValidate(opts) {
+    const result = validateMigrationE2E(opts.manifest);
+    printJson(result, Boolean(opts.json));
+    if (opts.strict && !result.ready) {
+        throw new Error('Migration E2E gate is not ready: resolve every reported blocker.');
+    }
+}

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 {};