@ductape/cli 0.3.0 → 0.3.2

package/README.md

@@ -77,6 +77,8 @@ ductape cloud resources list|import|provision …
 ductape db <verb>                 # db-proxy runtime
 ductape graph <verb>              # graph-proxy runtime
 ductape secrets <verb>
+ductape marketplace search payments --json
+ductape marketplace get paystack --json
 ductape generate payload|snippet …
 ductape completion bash|zsh
 ```

package/dist/commands/apps-curate-postman.d.ts

@@ -0,0 +1,25 @@
+interface PostmanCandidate {
+    uid: string;
+    name: string;
+    description: string;
+    publisher: string;
+    publisherUrl?: string;
+    collectionUrl?: string;
+    logo?: string;
+    forkCount: number;
+    verified: boolean;
+    official: boolean;
+}
+export declare function parseExplorePage(html: string): PostmanCandidate[];
+export declare function reputation(candidate: PostmanCandidate): {
+    score: number;
+    reasons: string[];
+};
+export declare function runAppsCuratePostman(opts: {
+    profile?: string;
+    maxPages?: string;
+    minScore?: string;
+    state?: string;
+    apiKey?: string;
+}): Promise<void>;
+export {};

package/dist/commands/apps-curate-postman.js

@@ -0,0 +1,328 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import input from '@inquirer/input';
+import select from '@inquirer/select';
+import { importAppFromFile } from '../lib/app-import.js';
+import { getApp, listApps, listMarketplaceCategories, updateApp, } from '../lib/platform-api.js';
+import { success } from '../lib/output.js';
+import { requireWorkspaceContext } from '../lib/workspace-context.js';
+const EXPLORE_URL = 'https://www.postman.com/explore/collections';
+const DEFAULT_STATE = '.ductape/postman-marketplace-curator.json';
+function text(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function number(value) {
+    return typeof value === 'number' ? value : Number(value) || 0;
+}
+function slugify(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+}
+function walk(value, visit) {
+    if (Array.isArray(value)) {
+        value.forEach((item) => walk(item, visit));
+        return;
+    }
+    if (!value || typeof value !== 'object')
+        return;
+    const object = value;
+    visit(object);
+    Object.values(object).forEach((item) => walk(item, visit));
+}
+function candidateFromObject(item) {
+    const kind = text(item.entityType || item.type || item.elementType).toLowerCase();
+    const uid = text(item.uid || item.collectionUid || item.collectionId || item.id);
+    const name = text(item.name || item.title);
+    const hasCollectionIdentity = Boolean(item.collectionUid || item.collectionId);
+    if (!uid || !name || (kind ? !kind.includes('collection') : !hasCollectionIdentity))
+        return null;
+    const publisherObject = (item.publisher || item.organization || item.team || item.owner || {});
+    const publisher = text(item.publisherName || item.teamName || publisherObject.name || publisherObject.username);
+    const collectionUrl = text(item.url || item.href || item.publicUrl);
+    return {
+        uid,
+        name,
+        description: text(item.description || item.summary),
+        publisher,
+        publisherUrl: text(publisherObject.url || publisherObject.profileUrl) || undefined,
+        collectionUrl: collectionUrl || undefined,
+        logo: text(item.logo || item.icon || publisherObject.logo) || undefined,
+        forkCount: number(item.forkCount || item.forks || item.fork_count),
+        verified: Boolean(item.verified || item.isVerified || publisherObject.verified),
+        official: Boolean(item.official || item.isOfficial || item.publisherType === 'official'),
+    };
+}
+export function parseExplorePage(html) {
+    const found = new Map();
+    const scriptPattern = /<script[^>]*>([\s\S]*?)<\/script>/gi;
+    for (const match of html.matchAll(scriptPattern)) {
+        const raw = match[1]?.trim();
+        if (!raw || (!raw.startsWith('{') && !raw.startsWith('[')))
+            continue;
+        try {
+            walk(JSON.parse(raw), (item) => {
+                const candidate = candidateFromObject(item);
+                if (candidate)
+                    found.set(candidate.uid, candidate);
+            });
+        }
+        catch {
+            // Framework payloads that are not plain JSON are covered by the URL fallback below.
+        }
+    }
+    const linkPattern = /https?:\/\/www\.postman\.com\/([^/"'?#]+)\/([^/"'?#]+)\/(?:collection|documentation)\/([a-zA-Z0-9-]+)(?:\/([^"'?#<]+))?/g;
+    for (const match of html.matchAll(linkPattern)) {
+        const uid = match[3];
+        if (!uid || found.has(uid))
+            continue;
+        found.set(uid, {
+            uid,
+            name: (match[4] || uid).split('/')[0].replace(/-/g, ' '),
+            description: '',
+            publisher: match[1],
+            collectionUrl: match[0],
+            forkCount: 0,
+            verified: false,
+            official: false,
+        });
+    }
+    return [...found.values()];
+}
+export function reputation(candidate) {
+    let score = 0;
+    const reasons = [];
+    if (candidate.official) {
+        score += 5;
+        reasons.push('official publisher');
+    }
+    if (candidate.verified) {
+        score += 4;
+        reasons.push('verified publisher');
+    }
+    if (candidate.forkCount >= 10_000) {
+        score += 4;
+        reasons.push(`${candidate.forkCount.toLocaleString()} forks`);
+    }
+    else if (candidate.forkCount >= 1_000) {
+        score += 3;
+        reasons.push(`${candidate.forkCount.toLocaleString()} forks`);
+    }
+    else if (candidate.forkCount >= 100) {
+        score += 2;
+        reasons.push(`${candidate.forkCount.toLocaleString()} forks`);
+    }
+    const publisher = slugify(candidate.publisher);
+    const name = slugify(candidate.name);
+    if (publisher && name && (name.includes(publisher) || publisher.includes(name.split('-')[0]))) {
+        score += 2;
+        reasons.push('publisher/API identity match');
+    }
+    if (candidate.publisherUrl) {
+        score += 1;
+        reasons.push('publisher profile');
+    }
+    return { score, reasons };
+}
+async function fetchJson(url, apiKey) {
+    const response = await fetch(url, {
+        headers: {
+            Accept: 'application/json',
+            ...(apiKey ? { 'X-Api-Key': apiKey } : {}),
+        },
+    });
+    if (!response.ok)
+        throw new Error(`${url} returned HTTP ${response.status}`);
+    return await response.json();
+}
+async function downloadCollection(candidate, apiKey) {
+    const urls = [
+        `https://api.postman.com/collections/${encodeURIComponent(candidate.uid)}`,
+        `https://api.getpostman.com/collections/${encodeURIComponent(candidate.uid)}`,
+        `https://www.postman.com/collections/${encodeURIComponent(candidate.uid)}`,
+    ];
+    let lastError;
+    for (const url of urls) {
+        try {
+            const result = await fetchJson(url, apiKey);
+            const collection = result.collection;
+            if (collection && typeof collection === 'object')
+                return collection;
+            if (result.info && result.item)
+                return result;
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw new Error(`Unable to download ${candidate.uid}. Set POSTMAN_API_KEY to use the official Postman API. ${String(lastError)}`);
+}
+function loadState(file) {
+    if (!fs.existsSync(file))
+        return { processed: {} };
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+function saveState(file, state) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(state, null, 2)}\n`);
+}
+function suggestDomains(candidate, domains) {
+    const haystack = `${candidate.name} ${candidate.description}`.toLowerCase();
+    const aliases = {
+        payments: ['payment', 'checkout', 'payout', 'fintech'],
+        'subscriptions-billing': ['subscription', 'billing', 'invoice'],
+        'crm-sales': ['crm', 'sales', 'customer support'],
+        messaging: ['sms', 'message', 'chat', 'push'],
+        email: ['email'],
+        'ai-machine-learning': [' ai ', 'machine learning', 'model'],
+        'developer-tools': ['developer', 'api', 'cloud', 'code'],
+        'maps-location': ['map', 'location', 'geocod'],
+        'shipping-delivery': ['shipping', 'delivery', 'logistics'],
+    };
+    return domains
+        .filter((domain) => {
+        const slug = text(domain.slug);
+        return (aliases[slug] || []).some((term) => ` ${haystack} `.includes(term));
+    })
+        .map((domain) => text(domain.slug));
+}
+function domainIds(slugs, domains) {
+    return domains
+        .filter((domain) => slugs.includes(text(domain.slug)))
+        .map((domain) => text(domain._id))
+        .filter(Boolean);
+}
+function marketplaceMetadata(candidate, collection) {
+    const info = (collection.info || {});
+    const description = text(info.description) || candidate.description ||
+        `${candidate.name} API collection published by ${candidate.publisher}.`;
+    const requestCount = JSON.stringify(collection).match(/"request"\s*:/g)?.length ?? 0;
+    const source = candidate.collectionUrl || `https://www.postman.com/explore/collections`;
+    const aboutText = [
+        description,
+        `Imported from the public Postman API Network collection maintained by ${candidate.publisher || 'its publisher'}.`,
+        `This version contains approximately ${requestCount} documented requests. Review authentication, environment variables, and provider terms before production use.`,
+        `Source: ${source}`,
+    ].join('\n\n').slice(0, 5000);
+    const aboutHTML = `<p>${aboutText
+        .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+        .replace(/\n\n/g, '</p><p>')}</p>`.slice(0, 5000);
+    return {
+        app_name: candidate.name.slice(0, 100),
+        description: description.slice(0, 1000),
+        aboutText,
+        aboutHTML,
+        website: candidate.publisherUrl || candidate.collectionUrl,
+        ...(candidate.logo?.startsWith('http') ? { logo: candidate.logo } : {}),
+        require_whitelist: false,
+    };
+}
+async function findImportedApp(ctx, beforeIds, collectionName) {
+    const apps = await listApps(ctx, 'all');
+    const created = apps.find((app) => !beforeIds.has(text(app._id)));
+    const named = apps.find((app) => text(app.app_name) === collectionName);
+    const result = created || named;
+    if (!result?._id)
+        throw new Error(`Import completed but app "${collectionName}" could not be located`);
+    return result;
+}
+export async function runAppsCuratePostman(opts) {
+    const ctx = requireWorkspaceContext({ profile: opts.profile });
+    const maxPages = Math.max(1, Number(opts.maxPages || 250));
+    const minScore = Math.max(0, Number(opts.minScore || 5));
+    const stateFile = path.resolve(opts.state || DEFAULT_STATE);
+    const state = loadState(stateFile);
+    const domains = await listMarketplaceCategories(ctx);
+    const apiKey = opts.apiKey || process.env.POSTMAN_API_KEY;
+    let emptyPages = 0;
+    for (let page = 1; page <= maxPages && emptyPages < 2; page++) {
+        const url = `${EXPLORE_URL}?sort=forkCount&page=${page}&filter=this_week`;
+        const response = await fetch(url, { headers: { Accept: 'text/html' } });
+        if (!response.ok)
+            throw new Error(`Postman Explore page ${page} returned HTTP ${response.status}`);
+        const candidates = parseExplorePage(await response.text());
+        if (candidates.length === 0) {
+            emptyPages++;
+            continue;
+        }
+        emptyPages = 0;
+        for (const candidate of candidates) {
+            if (state.processed[candidate.uid])
+                continue;
+            const trust = reputation(candidate);
+            if (trust.score < minScore)
+                continue;
+            console.log(`\n${candidate.name} by ${candidate.publisher || 'unknown publisher'}`);
+            console.log(`Reputation ${trust.score}: ${trust.reasons.join(', ') || 'limited evidence'}`);
+            if (candidate.collectionUrl)
+                console.log(candidate.collectionUrl);
+            const decision = await select({
+                message: 'Add or update this Ductape app?',
+                choices: [
+                    { name: 'Skip', value: 'skip' },
+                    { name: 'Add as new app', value: 'add' },
+                    { name: 'Update existing app/version', value: 'update' },
+                    { name: 'Stop and save progress', value: 'stop' },
+                ],
+            });
+            if (decision === 'stop') {
+                saveState(stateFile, state);
+                return;
+            }
+            if (decision === 'skip') {
+                state.processed[candidate.uid] = 'skipped';
+                saveState(stateFile, state);
+                continue;
+            }
+            const defaultTag = `${slugify(candidate.publisher || candidate.name)}:${slugify(candidate.name)}`;
+            const appTag = await input({ message: 'Ductape app tag', default: defaultTag });
+            const version = await input({
+                message: 'App version',
+                default: new Date().toISOString().slice(0, 10).replace(/-/g, '.'),
+            });
+            const suggested = suggestDomains(candidate, domains);
+            const selectedSlugs = (await input({
+                message: 'Domain slugs (comma-separated)',
+                default: suggested.join(','),
+            })).split(',').map((item) => item.trim()).filter(Boolean);
+            const selectedDomainIds = domainIds(selectedSlugs, domains);
+            if (selectedDomainIds.length !== selectedSlugs.length) {
+                const known = new Set(domains.map((domain) => text(domain.slug)));
+                const unknown = selectedSlugs.filter((slug) => !known.has(slug));
+                throw new Error(`Unknown marketplace domain slug(s): ${unknown.join(', ')}`);
+            }
+            const collection = await downloadCollection(candidate, apiKey);
+            const tempFile = path.join(path.dirname(stateFile), `${slugify(candidate.uid)}.postman_collection.json`);
+            fs.mkdirSync(path.dirname(tempFile), { recursive: true });
+            fs.writeFileSync(tempFile, `${JSON.stringify(collection, null, 2)}\n`);
+            const before = await listApps(ctx, 'all');
+            const beforeIds = new Set(before.map((app) => text(app._id)));
+            let target;
+            if (decision === 'update') {
+                target = await getApp(ctx, { tag: appTag });
+                if (!target?._id)
+                    throw new Error(`Existing app not found: ${appTag}`);
+            }
+            await importAppFromFile(ctx, {
+                filePath: tempFile,
+                format: 'postman',
+                appId: target ? text(target._id) : undefined,
+                update: decision === 'update',
+                version,
+            });
+            target = target || await findImportedApp(ctx, beforeIds, text(collection.info?.name) || candidate.name);
+            await updateApp(ctx, text(target._id), {
+                component: 'app',
+                tag: appTag,
+                version,
+                domains: selectedDomainIds,
+                status: 'pending_review',
+                workspace_id: ctx.workspaceId,
+                ...marketplaceMetadata(candidate, collection),
+            });
+            fs.unlinkSync(tempFile);
+            state.processed[candidate.uid] = decision === 'update' ? 'updated' : 'imported';
+            saveState(stateFile, state);
+            success(`${candidate.name} submitted for marketplace review as ${appTag}@${version}`);
+        }
+    }
+    saveState(stateFile, state);
+}

package/dist/commands/db-migrate.js

@@ -11,15 +11,41 @@ async function getAppliedTags(proxy, dbContext) {
         const result = await proxy.execute('migration.history', [], dbContext);
         const list = Array.isArray(result)
             ? result
-            : Array.isArray(result.data)
+            : result !== null
+                && typeof result === 'object'
+                && Array.isArray(result.data)
                 ? result.data
-                : [];
-        return list.map((r) => r.tag ?? '').filter(Boolean);
+                : null;
+        if (!Array.isArray(list)) {
+            throw new Error('migration.history returned an invalid response instead of a history array');
+        }
+        return list.map((entry, index) => {
+            if (entry === null || typeof entry !== 'object' || typeof entry.tag !== 'string') {
+                throw new Error(`migration.history returned an invalid entry at index ${index}`);
+            }
+            return entry.tag;
+        });
     }
-    catch {
-        return [];
+    catch (error) {
+        throw new Error(`Could not read migration history for ${dbContext.product}/${dbContext.database}:${dbContext.env}. ` +
+            'Migration state is unknown; no migrations were classified as pending.', { cause: error });
     }
 }
+function getMigrationResult(response, migrationTag) {
+    if (response === null || typeof response !== 'object')
+        return null;
+    const result = response[migrationTag];
+    if (result === null || typeof result !== 'object')
+        return null;
+    const success = result.success;
+    if (typeof success !== 'boolean')
+        return null;
+    const error = result.error;
+    return {
+        success,
+        ...(typeof error === 'string' ? { error } : {}),
+    };
+}
 export async function runDbMigrate(opts) {
     const found = findProjectConfig();
     if (!found)
@@ -59,13 +85,26 @@ export async function runDbMigrate(opts) {
             }
             process.stdout.write(`  Applying ${migration.tag}... `);
             try {
-                await proxy.execute('migration.run', [[migration]], dbContext);
+                const response = await proxy.execute('migration.run', [[migration]], dbContext);
+                const migrationResult = getMigrationResult(response, migration.tag);
+                if (migrationResult && !migrationResult.success) {
+                    throw new Error(migrationResult.error ?? 'SDK reported an unsuccessful migration');
+                }
+                // A successful HTTP response is not proof that the migration was
+                // recorded. Verify history before claiming success, including when
+                // talking to older proxies that serialize Map results as `{}`.
+                const appliedAfterRun = await getAppliedTags(proxy, dbContext);
+                if (!appliedAfterRun.includes(migration.tag)) {
+                    throw new Error('the operation returned without error, but the migration tag is absent from migration history');
+                }
                 console.log('done');
                 totalApplied++;
             }
             catch (err) {
-                console.log('failed');
-                fail(`Migration "${migration.tag}" failed: ${err instanceof Error ? err.message : String(err)}`);
+                console.log('unverified');
+                fail(`Migration "${migration.tag}" could not be verified: ` +
+                    `${err instanceof Error ? err.message : String(err)}. ` +
+                    'Do not rerun it until the live schema and migration history have been inspected.');
             }
         }
     }

package/dist/commands/marketplace.d.ts

@@ -0,0 +1,8 @@
+export declare function runMarketplace(verb: string, opts: {
+    profile?: string;
+    query?: string;
+    category?: string;
+    limit?: string;
+    tag?: string;
+    json?: boolean;
+}, args: string[]): Promise<void>;

package/dist/commands/marketplace.js

@@ -0,0 +1,30 @@
+import { getMarketplaceApp, listMarketplaceCategories, searchMarketplaceApps, } from '../lib/platform-api.js';
+import { printJson } from '../lib/output.js';
+import { requireWorkspaceContext } from '../lib/workspace-context.js';
+export async function runMarketplace(verb, opts, args) {
+    const ctx = requireWorkspaceContext({ profile: opts.profile });
+    let result;
+    switch (verb.toLowerCase()) {
+        case 'search':
+        case 'list':
+            result = await searchMarketplaceApps(ctx, {
+                query: opts.query ?? (args.join(' ') || undefined),
+                category: opts.category,
+                limit: opts.limit ? Number(opts.limit) : undefined,
+            });
+            break;
+        case 'get': {
+            const tag = opts.tag ?? args[0];
+            if (!tag)
+                throw new Error('marketplace get requires <tag> or --tag <tag>');
+            result = await getMarketplaceApp(ctx, tag);
+            break;
+        }
+        case 'categories':
+            result = await listMarketplaceCategories(ctx);
+            break;
+        default:
+            throw new Error('Unknown marketplace verb. Use: search, list, get, categories');
+    }
+    printJson(result, Boolean(opts.json));
+}

package/dist/commands/migrate-codebase.d.ts

@@ -4,6 +4,18 @@ interface MigrationPlan {
     version: 2;
     artifact_kind: 'ai_review_bootstrap';
     authority: 'advisory_only';
+    execution_provenance?: {
+        mcp_client?: {
+            name: string;
+            version: string;
+            source: 'mcp_initialize_handshake';
+            trust: 'protocol_asserted_unverified';
+        };
+        ai_model: {
+            status: 'unavailable';
+            reason: 'MCP does not provide a server-verifiable model identity';
+        };
+    };
     source: string;
     mode: MigrationMode;
     destination: string;
@@ -137,6 +149,13 @@ interface MigrationPlan {
     ai_working_standards: {
         global: string[];
         languages: Record<Language, string[]>;
+        feature_classification: {
+            definition: string;
+            categories: Record<'FEATURE' | 'FEATURE_STEP' | 'DOMAIN_SERVICE' | 'UTILITY' | 'INFRASTRUCTURE_ADAPTER', string>;
+            discovery: string[];
+            required_output_fields: string[];
+            grouping_rule: string;
+        };
     };
     output_paths: {
         plan: string;
@@ -172,5 +191,7 @@ export declare function runMigrateCodebase(opts: {
     ensureProduct?: boolean;
     write?: boolean;
     json?: boolean;
+    mcpClientName?: string;
+    mcpClientVersion?: string;
 }): Promise<void>;
 export {};

package/dist/commands/migrate-codebase.js

@@ -288,17 +288,26 @@ function detectSecretReferences(texts) {
     const found = new Map();
     const rules = [
         ['github', /\$\{\{\s*secrets\.([A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g],
+        ['github', /\$\{\{\s*secrets\[['"]([A-Za-z_][A-Za-z0-9_]*)['"]\]\s*\}\}/g],
         ['gitlab', /\$\{?([A-Z][A-Z0-9_]*(?:TOKEN|SECRET|PASSWORD|KEY|CREDENTIAL)[A-Z0-9_]*)\}?/g],
+        ['gitlab', /\bvault\s*:\s*['"]?([A-Za-z0-9_./@-]+)/g],
         ['jenkins', /\bcredentials\(\s*['"]([^'"]+)['"]\s*\)/g],
+        ['jenkins', /\bcredentialsId\s*:\s*['"]([^'"]+)['"]/g],
         ['kubernetes', /\bsecretKeyRef\s*:\s*(?:\r?\n[ \t]+[^\n]*)*?\r?\n[ \t]+key\s*:\s*['"]?([A-Za-z0-9_.-]+)/g],
         ['kubernetes', /\bremoteRef\s*:\s*(?:\r?\n[ \t]+[^\n]*)*?\r?\n[ \t]+key\s*:\s*['"]?([A-Za-z0-9_./-]+)/g],
+        ['kubernetes', /\b(?:secretName|secretProviderClass)\s*:\s*['"]?([A-Za-z0-9_.-]+)/g],
+        ['kubernetes', /\bsecretRef\s*:\s*(?:\r?\n[ \t]+[^\n]*)*?\r?\n[ \t]+name\s*:\s*['"]?([A-Za-z0-9_.-]+)/g],
         ['spring', /\$\{([A-Za-z_][A-Za-z0-9_.-]*)(?::[^}]*)?\}/g],
         ['dotnet', /(?:GetConnectionString\(\s*|Configuration\s*\[\s*)['"]([^'"]+)['"]/g],
         ['dotnet', /<UserSecretsId>\s*([^<\r\n]+)\s*<\/UserSecretsId>/g],
         ['terraform', /\bvar\.([A-Za-z_][A-Za-z0-9_]*)/g],
         ['aws', /(?:secretsmanager|secret-id|secretId)[/:="'\s]+([A-Za-z0-9_./-]+)/gi],
+        ['aws', /\{\{resolve:(?:secretsmanager|ssm-secure):([^}:]+)/gi],
+        ['aws', /arn:aws:secretsmanager:[^:\s]+:[^:\s]+:secret:([A-Za-z0-9_./+=@-]+)/gi],
         ['gcp', /(?:secretmanager|secretVersion|secret-version)[/:="'\s]+([A-Za-z0-9_./-]+)/gi],
+        ['gcp', /projects\/[^/\s]+\/secrets\/([A-Za-z0-9_-]+)/gi],
         ['azure', /(?:vault\.azure\.net\/secrets\/|secretName\s*[:=]\s*['"])([A-Za-z0-9_.-]+)/gi],
+        ['azure', /@Microsoft\.KeyVault\(\s*SecretUri=https:\/\/[^/\s]+\.vault\.azure\.net\/secrets\/([A-Za-z0-9_.-]+)/gi],
         ['docker', /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::?-[^}]*)?\}/g],
         ['circleci', /\$\{?([A-Z][A-Z0-9_]*(?:TOKEN|SECRET|PASSWORD|KEY|CREDENTIAL)[A-Z0-9_]*)\}?/g],
         ['azure_devops', /\$\(([A-Za-z_][A-Za-z0-9_.-]*(?:TOKEN|SECRET|PASSWORD|KEY|CREDENTIAL)[A-Za-z0-9_.-]*)\)/gi],
@@ -470,6 +479,8 @@ const FILE_REVIEW_CHECKLIST = [
     'configuration and secret-name references',
     'database reads, writes, transactions, schemas, and migrations',
     'internal events, queues, schedules, and background work',
+    'named capability candidates across exports, public methods, controllers, consumers, jobs, repeated orchestration, typed operations, documentation, and routes',
+    'whether related low-level operations collectively form one FEATURE, FEATURE_STEP, DOMAIN_SERVICE, UTILITY, or INFRASTRUCTURE_ADAPTER boundary',
     'external HTTP/API integrations and authentication',
     'sessions, actor propagation, authorization, and privacy',
     'cache, storage, notifications, graph, and vector usage',
@@ -621,6 +632,27 @@ function buildPlan(source, files, scanPolicy, mode, destination, productTag, pro
                     'Preserve request scope and dispose SDK-owned resources through the host lifecycle.',
                 ],
             },
+            feature_classification: {
+                definition: 'A named, reusable product capability with a stable input/output contract that benefits from managed execution, composition, observability, retries, versioning, policy enforcement, or explicit execution steps. It may be synchronous and local.',
+                categories: {
+                    FEATURE: 'Independently meaningful product capability; make it a standalone Ductape Feature.',
+                    FEATURE_STEP: 'Meaningful stage without a useful independent boundary; expose it as a named ctx.step inside another Feature.',
+                    DOMAIN_SERVICE: 'Reusable domain logic without a useful independent managed-execution boundary; keep it as domain logic called by a Feature.',
+                    UTILITY: 'Low-level hashing, formatting, redaction, normalization, conversion, or type-guard helper; keep it as a utility.',
+                    INFRASTRUCTURE_ADAPTER: 'Database, Event, HTTP, cache, storage, transport, provider, or framework integration; keep it as an infrastructure adapter.',
+                },
+                discovery: [
+                    'Exported functions and public service methods; export alone is neither sufficient nor necessary.',
+                    'Controller entry points, Event consumers, scheduled jobs, and repeated orchestration sequences.',
+                    'Domain operations reused from several locations and functions with substantial typed inputs and outputs.',
+                    'Functions composing several meaningful domain stages and product terminology in documentation and API routes.',
+                ],
+                required_output_fields: [
+                    'candidate', 'classification', 'executionStyle', 'evidence', 'suggestedSteps',
+                    'signalsRequired', 'eventsRequired', 'recommendation',
+                ],
+                grouping_rule: 'Group related low-level operations into one coherent capability candidate; never recommend one Feature per exported function.',
+            },
         },
         output_paths: {
             plan: planPath,
@@ -656,6 +688,20 @@ ${plan.ai_working_standards.global.map((rule) => `- ${rule}`).join('\n')}
 
 ${languageSections || 'No supported server language was detected. The AI must inspect the repository before proceeding.'}
 
+## Feature capability classification
+
+${plan.ai_working_standards.feature_classification.definition}
+
+${Object.entries(plan.ai_working_standards.feature_classification.categories)
+        .map(([category, rule]) => `- **${category}**: ${rule}`).join('\n')}
+
+Discovery must cover:
+${plan.ai_working_standards.feature_classification.discovery.map((item) => `- ${item}`).join('\n')}
+
+- ${plan.ai_working_standards.feature_classification.grouping_rule}
+- Every recommendation must include: ${plan.ai_working_standards.feature_classification.required_output_fields.join(', ')}.
+- Signals and Events are optional; synchronous multi-step capabilities remain valid Feature candidates.
+
 ## Workflow
 
 1. Before this plan, create missing project-level E2E tests, run them against the original codebase, and record a passing checksum-bound \`migration-e2e\` baseline.
@@ -727,6 +773,20 @@ export async function runMigrateCodebase(opts) {
     });
     const productTag = plan.product.tag;
     const productName = plan.product.name;
+    if (opts.mcpClientName && opts.mcpClientVersion) {
+        plan.execution_provenance = {
+            mcp_client: {
+                name: opts.mcpClientName,
+                version: opts.mcpClientVersion,
+                source: 'mcp_initialize_handshake',
+                trust: 'protocol_asserted_unverified',
+            },
+            ai_model: {
+                status: 'unavailable',
+                reason: 'MCP does not provide a server-verifiable model identity',
+            },
+        };
+    }
     if (opts.ensureProduct) {
         const context = requireWorkspaceContext({});
         try {

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

@@ -1,20 +1,15 @@
+type JsonSchema = {
+    $schema: string;
+    title: string;
+    type: 'object';
+    required: string[];
+    properties: Record<string, unknown>;
+    additionalProperties: boolean;
+};
 export declare const MIGRATION_ARTIFACT_SCHEMAS: {
     version: number;
-    artifacts: {
-        $schema: string;
-        title: string;
-        type: string;
-        required: string[];
-        properties: {
-            version: {
-                const: number;
-            };
-            artifact_kind: {
-                const: string;
-            };
-        };
-        additionalProperties: boolean;
-    }[];
+    artifacts: JsonSchema[];
+    definitions: JsonSchema[];
 };
 export declare function runMigrationArtifactValidate(opts: {
     file: string;
@@ -30,3 +25,4 @@ export declare function runMigrationArtifactMigrate(opts: {
     json?: boolean;
 }): void;
 export declare function runMigrationArtifactSchemas(json?: boolean): void;
+export {};

package/dist/commands/migration-artifact.js

@@ -1,39 +1,92 @@
 import path from 'node:path';
 import { printJson } from '../lib/output.js';
 import { migrateMigrationJson, readMigrationJson, recoverMigrationJson, } from '../lib/migration-artifact.js';
+const objectSchema = (title, required, properties = {}) => ({
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    title,
+    type: 'object',
+    required,
+    properties,
+    additionalProperties: true,
+});
+const artifact = (kind, required) => objectSchema(kind, ['version', 'artifact_kind', ...required], { version: { const: 1 }, artifact_kind: { const: kind } });
 export const MIGRATION_ARTIFACT_SCHEMAS = {
-    version: 1,
+    version: 2,
     artifacts: [
-        'ai_migration_review_ledger',
-        'ductape_migration_slice',
-        'ductape_migration_portfolio',
-        'ductape_migration_partition_proposal',
-        'ductape_migration_e2e_baseline',
-        'ductape_migration_generated_vendor_evidence',
-        'ductape_migration_assurance',
-        'ductape_migration_verification_matrix',
-        'ductape_database_baseline',
-        'ductape_database_data',
-        'ductape_database_cutover',
-        'ductape_review_ledger_signature',
-    ].map((artifact_kind) => ({
-        $schema: 'https://json-schema.org/draft/2020-12/schema',
-        title: artifact_kind,
-        type: 'object',
-        required: ['version', 'artifact_kind'],
-        properties: {
-            version: { const: 1 },
-            artifact_kind: { const: artifact_kind },
-        },
-        additionalProperties: true,
-    })),
+        artifact('ai_review_bootstrap', ['authority', 'source', 'mode', 'destination', 'review_queue']),
+        artifact('ai_migration_review_ledger', ['source', 'entries']),
+        artifact('ductape_migration_slice', ['tag', 'name', 'ledger', 'files', 'surfaces', 'product_boundary']),
+        artifact('ductape_migration_portfolio', ['ledger', 'partitions', 'slices', 'cross_slice_contracts']),
+        artifact('ductape_migration_partition_proposal', ['authority', 'ledger', 'limits', 'partitions']),
+        artifact('ductape_migration_e2e_baseline', ['source', 'created_at', 'command', 'suite', 'baseline', 'final']),
+        artifact('ductape_migration_generated_vendor_evidence', ['analysis', 'generated', 'vendor']),
+        artifact('ductape_migration_assurance', [
+            'session_flows', 'feature_resilience', 'third_party_calls', 'components',
+            'provider_migrations', 'runtime', 'sdk_matrix',
+        ]),
+        artifact('ductape_migration_verification_matrix', ['categories']),
+        artifact('ductape_database_baseline', [
+            'migration_id', 'database_tag', 'owners', 'providers', 'schema_snapshots',
+            'structural_comparison',
+        ]),
+        artifact('ductape_database_data', [
+            'migration_id', 'transformations', 'batching', 'checkpoints', 'idempotency',
+            'resume_strategy', 'validation', 'reconciliation',
+        ]),
+        artifact('ductape_database_cutover', [
+            'migration_id', 'phases', 'expand', 'backfill', 'dual_compatibility', 'contract',
+            'deployment_order', 'migration_locking', 'backup', 'restore_test', 'rollback',
+        ]),
+        artifact('ductape_review_ledger_signature', [
+            'ledger', 'ledger_sha256', 'algorithm', 'key_id', 'signature', 'signed_at',
+        ]),
+        artifact('ductape_service_product_map', ['analysis', 'mappings', 'assets', 'promotions']),
+        artifact('ductape_secret_migration_map', ['analysis', 'classifications']),
+        artifact('ductape_sdk_capability_matrix', ['authority', 'unsupported_policy', 'sdks']),
+    ],
+    definitions: [
+        objectSchema('migration_e2e_definition', ['command', 'suite_files', 'baseline']),
+        objectSchema('migration_e2e_final_evidence', ['command', 'status', 'evidence', 'environment', 'suite_root']),
+        objectSchema('migration_slice_definition', [
+            'surfaces', 'product_boundary', 'sdk_capabilities', 'interface_contracts',
+            'functional_requirements', 'operational_requirements', 'parity_evidence',
+            'frontend_parity', 'required_assets', 'tests', 'failure_tests', 'runtime_evidence',
+            'smoke_checks', 'cutover_conditions', 'rollback_conditions', 'deployment_cutover',
+        ]),
+        objectSchema('migration_portfolio_definition', ['partitions', 'slices', 'cross_slice_contracts']),
+        objectSchema('migration_database_definition', ['baseline', 'data', 'cutover']),
+        objectSchema('migration_product_map_definition', ['mappings', 'assets', 'promotions']),
+        objectSchema('migration_secret_map_definition', ['classifications']),
+        objectSchema('migration_generated_vendor_definition', ['generated', 'vendor']),
+        objectSchema('migration_review_record_definition', [
+            'purpose', 'dependencies', 'interfaces', 'functional_parity_requirements',
+            'operational_parity_requirements', 'findings',
+        ]),
+        objectSchema('migration_assurance_definition', [
+            'version', 'artifact_kind', 'session_flows', 'feature_resilience', 'third_party_calls',
+            'components', 'provider_migrations', 'runtime', 'sdk_matrix',
+        ]),
+        objectSchema('migration_verification_definition', ['version', 'artifact_kind', 'categories']),
+        objectSchema('migration_environment_inventory', ['environments']),
+    ],
 };
 export function runMigrationArtifactValidate(opts) {
     const value = readMigrationJson(opts.file);
-    const schema = MIGRATION_ARTIFACT_SCHEMAS.artifacts.find((candidate) => candidate.properties.artifact_kind.const === value.artifact_kind);
-    if (!schema || value.version !== 1)
+    const schema = MIGRATION_ARTIFACT_SCHEMAS.artifacts.find((candidate) => candidate.properties.artifact_kind?.const === value.artifact_kind);
+    if (!schema || value.version !== 1) {
         throw new Error('[ARTIFACT_VERSION_UNSUPPORTED] Unknown artifact kind or version.');
-    printJson({ file: path.resolve(opts.file), valid: true, artifact_kind: value.artifact_kind, version: value.version }, Boolean(opts.json));
+    }
+    const missing = schema.required.filter((field) => !(field in value) || value[field] == null);
+    if (missing.length) {
+        throw new Error(`[ARTIFACT_SCHEMA_INVALID] Missing required fields: ${missing.join(', ')}`);
+    }
+    printJson({
+        file: path.resolve(opts.file),
+        valid: true,
+        artifact_kind: value.artifact_kind,
+        version: value.version,
+        schema_catalog_version: MIGRATION_ARTIFACT_SCHEMAS.version,
+    }, Boolean(opts.json));
 }
 export function runMigrationArtifactRecover(opts) {
     recoverMigrationJson(opts.file);

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

@@ -0,0 +1,53 @@
+export type SupportedLanguage = 'typescript' | 'go' | 'java' | 'dotnet';
+export declare const SDK_CAPABILITY_MATRIX: {
+    readonly version: 1;
+    readonly artifact_kind: "ductape_sdk_capability_matrix";
+    readonly authority: "source_verified_catalog";
+    readonly generated_from: "repository source; update and test this catalog with every supported SDK release";
+    readonly unsupported_policy: {
+        readonly rule: "Never infer cross-language parity or synthesize a missing API.";
+        readonly action: "Inspect the installed package exports, record the capability as unsupported, and stop for an approved fallback.";
+    };
+    readonly sdks: readonly [{
+        readonly language: "typescript";
+        readonly package: "@ductape/sdk";
+        readonly version: "0.1.101";
+        readonly status: "supported";
+        readonly source_version: "sdk/ts/package.json";
+        readonly public_surface_evidence: "sdk/ts/src/index.ts";
+        readonly capabilities: readonly ["actions", "agents", "cache", "cloud", "databases", "events", "features", "graphs", "imports", "jobs", "logs", "models", "notifications", "products", "resilience", "secrets", "sessions", "storage", "vectors", "warehouse"];
+        readonly lifecycle: readonly ["await asynchronous operations", "close/disconnect owned clients during application shutdown"];
+    }, {
+        readonly language: "go";
+        readonly package: "github.com/ductape/ductape/sdk/go";
+        readonly version: "v0.0.1";
+        readonly status: "supported";
+        readonly source_version: "sdk/go git tag v0.0.1";
+        readonly public_surface_evidence: "sdk/go/ductape";
+        readonly capabilities: readonly ["actions", "agents", "cache", "cloud", "databases", "events", "features", "graphs", "imports", "jobs", "logs", "models", "notifications", "products", "resilience", "secrets", "sessions", "storage", "vectors", "warehouse"];
+        readonly lifecycle: readonly ["propagate context.Context cancellation", "close owned clients during application shutdown"];
+    }, {
+        readonly language: "java";
+        readonly package: "app.ductape:ductape-sdk";
+        readonly version: "0.1.9-SNAPSHOT";
+        readonly status: "supported-source-snapshot";
+        readonly source_version: "sdk/java/build.gradle";
+        readonly public_surface_evidence: "sdk/java/src/main/java/app/ductape/sdk/Ductape.java";
+        readonly capabilities: readonly ["actions", "agents", "cache", "cloud", "databases", "events", "features", "graphs", "imports", "jobs", "logs", "models", "notifications", "products", "resilience", "secrets", "sessions", "storage", "vectors", "warehouse"];
+        readonly lifecycle: readonly ["propagate interruption/cancellation", "close owned clients during application shutdown"];
+    }, {
+        readonly language: "dotnet";
+        readonly package: "Ductape.Sdk";
+        readonly version: "0.1.12";
+        readonly status: "supported";
+        readonly source_version: "sdk/dotnet/src/Ductape.Sdk/Ductape.Sdk.csproj";
+        readonly public_surface_evidence: "sdk/dotnet/src/Ductape.Sdk/Ductape.cs";
+        readonly capabilities: readonly ["actions", "agents", "cache", "cloud", "databases", "events", "features", "graphs", "imports", "jobs", "logs", "models", "notifications", "products", "resilience", "secrets", "sessions", "storage", "vectors", "warehouse"];
+        readonly lifecycle: readonly ["propagate CancellationToken", "dispose owned clients during application shutdown"];
+    }];
+};
+export declare function runMigrationCapabilities(opts: {
+    language?: SupportedLanguage;
+    version?: string;
+    json?: boolean;
+}): void;

package/dist/commands/migration-capabilities.js

@@ -0,0 +1,66 @@
+import { printJson } from '../lib/output.js';
+const COMMON_RUNTIME_CAPABILITIES = [
+    'actions', 'agents', 'cache', 'cloud', 'databases', 'events', 'features',
+    'graphs', 'imports', 'jobs', 'logs', 'models', 'notifications', 'products',
+    'resilience', 'secrets', 'sessions', 'storage', 'vectors', 'warehouse',
+];
+export const SDK_CAPABILITY_MATRIX = {
+    version: 1,
+    artifact_kind: 'ductape_sdk_capability_matrix',
+    authority: 'source_verified_catalog',
+    generated_from: 'repository source; update and test this catalog with every supported SDK release',
+    unsupported_policy: {
+        rule: 'Never infer cross-language parity or synthesize a missing API.',
+        action: 'Inspect the installed package exports, record the capability as unsupported, and stop for an approved fallback.',
+    },
+    sdks: [
+        {
+            language: 'typescript',
+            package: '@ductape/sdk',
+            version: '0.1.101',
+            status: 'supported',
+            source_version: 'sdk/ts/package.json',
+            public_surface_evidence: 'sdk/ts/src/index.ts',
+            capabilities: [...COMMON_RUNTIME_CAPABILITIES],
+            lifecycle: ['await asynchronous operations', 'close/disconnect owned clients during application shutdown'],
+        },
+        {
+            language: 'go',
+            package: 'github.com/ductape/ductape/sdk/go',
+            version: 'v0.0.1',
+            status: 'supported',
+            source_version: 'sdk/go git tag v0.0.1',
+            public_surface_evidence: 'sdk/go/ductape',
+            capabilities: [...COMMON_RUNTIME_CAPABILITIES],
+            lifecycle: ['propagate context.Context cancellation', 'close owned clients during application shutdown'],
+        },
+        {
+            language: 'java',
+            package: 'app.ductape:ductape-sdk',
+            version: '0.1.9-SNAPSHOT',
+            status: 'supported-source-snapshot',
+            source_version: 'sdk/java/build.gradle',
+            public_surface_evidence: 'sdk/java/src/main/java/app/ductape/sdk/Ductape.java',
+            capabilities: [...COMMON_RUNTIME_CAPABILITIES],
+            lifecycle: ['propagate interruption/cancellation', 'close owned clients during application shutdown'],
+        },
+        {
+            language: 'dotnet',
+            package: 'Ductape.Sdk',
+            version: '0.1.12',
+            status: 'supported',
+            source_version: 'sdk/dotnet/src/Ductape.Sdk/Ductape.Sdk.csproj',
+            public_surface_evidence: 'sdk/dotnet/src/Ductape.Sdk/Ductape.cs',
+            capabilities: [...COMMON_RUNTIME_CAPABILITIES],
+            lifecycle: ['propagate CancellationToken', 'dispose owned clients during application shutdown'],
+        },
+    ],
+};
+export function runMigrationCapabilities(opts) {
+    const sdks = SDK_CAPABILITY_MATRIX.sdks.filter((sdk) => (!opts.language || sdk.language === opts.language) &&
+        (!opts.version || sdk.version === opts.version));
+    if (!sdks.length) {
+        throw new Error(`No supported SDK capability matrix matches ${opts.language ?? '*'}@${opts.version ?? '*'}.`);
+    }
+    printJson({ ...SDK_CAPABILITY_MATRIX, sdks }, Boolean(opts.json));
+}

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

@@ -1,3 +1,8 @@
+export declare const REQUIRED_DATABASE_FIELDS: {
+    readonly baseline: readonly ["database_tag", "owners", "providers", "code_schema_evidence", "migration_history_evidence", "applied_history_evidence", "live_snd_schema_evidence", "proposed_schema_evidence", "drift", "objects", "security", "topology", "compatibility", "performance_baseline"];
+    readonly data: readonly ["transformations", "batching", "checkpoints", "idempotency", "resume_strategy", "validation", "reconciliation", "failure_recovery", "pii_controls", "retention", "seed_data"];
+    readonly cutover: readonly ["phases", "expand", "backfill", "dual_compatibility", "contract", "deployment_order", "migration_locking", "backup", "restore_test", "rollback", "irreversible_changes", "monitoring", "reconciliation", "approval"];
+};
 export declare function initDatabaseMigration(opts: {
     definition: string;
     output: string;

package/dist/commands/migration-database.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import crypto from 'node:crypto';
 import { printJson } from '../lib/output.js';
 import { readMigrationJson, writeMigrationJson } from '../lib/migration-artifact.js';
-const REQUIRED = {
+export const REQUIRED_DATABASE_FIELDS = {
     baseline: ['database_tag', 'owners', 'providers', 'code_schema_evidence', 'migration_history_evidence', 'applied_history_evidence', 'live_snd_schema_evidence', 'proposed_schema_evidence', 'drift', 'objects', 'security', 'topology', 'compatibility', 'performance_baseline'],
     data: ['transformations', 'batching', 'checkpoints', 'idempotency', 'resume_strategy', 'validation', 'reconciliation', 'failure_recovery', 'pii_controls', 'retention', 'seed_data'],
     cutover: ['phases', 'expand', 'backfill', 'dual_compatibility', 'contract', 'deployment_order', 'migration_locking', 'backup', 'restore_test', 'rollback', 'irreversible_changes', 'monitoring', 'reconciliation', 'approval'],
@@ -47,7 +47,7 @@ export function validateDatabaseMigration(directory) {
         if (artifact.version !== 1 || artifact.artifact_kind !== `ductape_database_${name}`) {
             blockers.push(`${name}: unsupported artifact version or kind`);
         }
-        for (const field of missing(artifact, REQUIRED[name]))
+        for (const field of missing(artifact, REQUIRED_DATABASE_FIELDS[name]))
             blockers.push(`${name}.${field}: evidence required`);
         if (!text(artifact.migration_id))
             blockers.push(`${name}.migration_id: required for cross-artifact consistency`);

package/dist/index.js

@@ -25,6 +25,7 @@ import { runCompletion } from './commands/completion.js';
 import { runProducts, runProductApps, runProductComponents, runProductEnvironments } from './commands/products.js';
 import { runApps } from './commands/apps.js';
 import { runAppsImport } from './commands/apps-import.js';
+import { runMarketplace } from './commands/marketplace.js';
 import { runApply } from './commands/apply.js';
 import { runMigrateCodebase } from './commands/migrate-codebase.js';
 import { runMigrationReviewInit, runMigrationReviewRecord, runMigrationReviewFollowUp, runMigrationReviewExclude, runMigrationReviewParity, runMigrationReviewReopen, runMigrationReviewMove, runMigrationReviewMerge, runMigrationReviewSign, runMigrationReviewSnapshot, runMigrationReviewVerifySignature, runMigrationReviewValidate, } from './commands/migration-review.js';
@@ -39,13 +40,18 @@ import { runMigrationGeneratedInit, runMigrationGeneratedValidate, } from './com
 import { runMigrationAssuranceValidate } from './commands/migration-assurance.js';
 import { runMigrationVerificationValidate } from './commands/migration-verification.js';
 import { runMigrationArtifactMigrate, runMigrationArtifactRecover, runMigrationArtifactSchemas, runMigrationArtifactValidate, } from './commands/migration-artifact.js';
+import { runMigrationCapabilities } from './commands/migration-capabilities.js';
+import { structuredMigrationError } from './lib/migration-artifact.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(path.join(__dirname, '../package.json'), 'utf8'));
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function wrap(fn) {
     return (...args) => {
-        Promise.resolve(fn(...args)).catch((err) => {
-            console.error(err instanceof Error ? err.message : err);
+        Promise.resolve().then(() => fn(...args)).catch((err) => {
+            const command = process.argv[2] ?? '';
+            console.error(command === 'migrate-codebase' || command.startsWith('migration-')
+                ? structuredMigrationError(err)
+                : err instanceof Error ? err.message : err);
             process.exit(1);
         });
     };
@@ -171,6 +177,8 @@ program
     .option('--exclude <patterns>', 'Comma-separated repository-relative glob patterns')
     .option('--ensure-product', 'Create the product when it does not exist')
     .option('--write', 'Write redacted advisory artifacts only; never writes application code or executable assets')
+    .option('--mcp-client-name <name>', 'Protocol-asserted MCP client name (unverified)', undefined)
+    .option('--mcp-client-version <version>', 'Protocol-asserted MCP client version (unverified)', undefined)
     .option('--json', 'JSON output')
     .action(wrap((opts) => runMigrateCodebase({
     source: opts.source,
@@ -186,6 +194,8 @@ program
     ensureProduct: Boolean(opts.ensureProduct),
     write: Boolean(opts.write),
     json: Boolean(opts.json),
+    mcpClientName: opts.mcpClientName,
+    mcpClientVersion: opts.mcpClientVersion,
 })));
 const migrationE2E = program
     .command('migration-e2e')
@@ -240,6 +250,17 @@ program
     strict: Boolean(opts.strict),
     json: Boolean(opts.json),
 })));
+program
+    .command('migration-capabilities')
+    .description('Print the source-verified capability matrix for supported SDK language/version pairs')
+    .option('--language <language>', 'typescript | go | java | dotnet')
+    .option('--version <version>', 'Exact supported SDK version')
+    .option('--json', 'JSON output')
+    .action(wrap((opts) => runMigrationCapabilities({
+    language: opts.language,
+    version: opts.version,
+    json: Boolean(opts.json),
+})));
 program
     .command('migration-verification')
     .description('Validate cited automation evidence for large-repo, parity, frontend, database, and asset migration')
@@ -595,6 +616,18 @@ apps
     version: opts.version,
     json: opts.json,
 })));
+program
+    .command('marketplace')
+    .description('Discover public apps by capability and inspect their actions')
+    .argument('<verb>', 'search | list | get | categories')
+    .argument('[terms...]', 'Capability terms for search, or app tag for get')
+    .option('--profile <name>')
+    .option('-q, --query <query>', 'Capability search query')
+    .option('-c, --category <category>', 'Filter by category/domain name')
+    .option('-l, --limit <count>', 'Maximum results', '20')
+    .option('-t, --tag <tag>', 'Marketplace app tag for get')
+    .option('--json', 'JSON output')
+    .action(wrap((verb, terms, opts) => runMarketplace(verb, opts, terms)));
 const events = program.command('events').description('Message broker CRUD (sdk-proxy, requires access key login)');
 const eventTopics = events.command('topics').description('Topic CRUD for a message broker');
 eventTopics

package/dist/lib/migration-artifact.d.ts

@@ -1,4 +1,10 @@
 export type MigrationArtifactErrorCode = 'ARTIFACT_TOO_LARGE' | 'ARTIFACT_INVALID_JSON' | 'ARTIFACT_SECRET_MATERIAL' | 'ARTIFACT_LOCKED' | 'ARTIFACT_EXISTS' | 'ARTIFACT_VERSION_UNSUPPORTED' | 'ARTIFACT_RECOVERY_FAILED';
+export declare const MIGRATION_ERROR_CODES: {
+    readonly validation: "MIGRATION_VALIDATION_FAILED";
+    readonly configuration: "MIGRATION_CONFIGURATION_INVALID";
+    readonly external: "MIGRATION_EXTERNAL_OPERATION_FAILED";
+};
+export declare function structuredMigrationError(error: unknown): string;
 export declare class MigrationArtifactError extends Error {
     readonly code: MigrationArtifactErrorCode;
     constructor(code: MigrationArtifactErrorCode, message: string);

package/dist/lib/migration-artifact.js

@@ -1,5 +1,16 @@
 import fs from 'node:fs';
 import path from 'node:path';
+export const MIGRATION_ERROR_CODES = {
+    validation: 'MIGRATION_VALIDATION_FAILED',
+    configuration: 'MIGRATION_CONFIGURATION_INVALID',
+    external: 'MIGRATION_EXTERNAL_OPERATION_FAILED',
+};
+export function structuredMigrationError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/^\[[A-Z0-9_]+\]/.test(message))
+        return message;
+    return `[${MIGRATION_ERROR_CODES.validation}] ${message}`;
+}
 export class MigrationArtifactError extends Error {
     code;
     constructor(code, message) {
@@ -37,8 +48,8 @@ export function readMigrationJson(file, maxBytes = 5_000_000) {
     try {
         value = JSON.parse(fs.readFileSync(resolved, 'utf8'));
     }
-    catch (error) {
-        throw new MigrationArtifactError('ARTIFACT_INVALID_JSON', `${resolved}: ${error instanceof Error ? error.message : String(error)}`);
+    catch {
+        throw new MigrationArtifactError('ARTIFACT_INVALID_JSON', `${resolved}: JSON parsing failed; parser context is intentionally suppressed to prevent evidence leakage.`);
     }
     inspect(value);
     return value;

package/dist/lib/platform-api.d.ts

@@ -17,6 +17,14 @@ export declare function createApp(ctx: WorkspaceContext, body: Record<string, un
 export declare function updateApp(ctx: WorkspaceContext, appId: string, body: Record<string, unknown>): Promise<unknown>;
 export declare function updateAppViaProxy(ctx: WorkspaceContext, tag: string, body: Record<string, unknown>): Promise<unknown>;
 export declare function deleteApp(ctx: WorkspaceContext, appId: string): Promise<unknown>;
+export interface MarketplaceSearchOptions {
+    query?: string;
+    category?: string;
+    limit?: number;
+}
+export declare function listMarketplaceCategories(ctx: WorkspaceContext): Promise<unknown[]>;
+export declare function getMarketplaceApp(ctx: WorkspaceContext, tag: string): Promise<unknown>;
+export declare function searchMarketplaceApps(ctx: WorkspaceContext, opts: MarketplaceSearchOptions): Promise<unknown[]>;
 export interface TierQuery {
     provider?: string;
     resource_type?: string;

package/dist/lib/platform-api.js

@@ -135,6 +135,61 @@ export async function deleteApp(ctx, appId) {
     };
     return client(ctx).delete(`/apps/v1/${appId}?${new URLSearchParams(q).toString()}`);
 }
+function searchableMarketplaceText(app) {
+    if (!app || typeof app !== 'object')
+        return '';
+    const value = app;
+    const version = value.currentVersion && typeof value.currentVersion === 'object'
+        ? value.currentVersion
+        : {};
+    const actions = Array.isArray(version.actions) ? version.actions : [];
+    const webhooks = Array.isArray(version.webhooks) ? version.webhooks : [];
+    return [
+        value.app_name,
+        value.tag,
+        value.description,
+        value.aboutText,
+        ...(Array.isArray(value.domains) ? value.domains : []),
+        ...actions.flatMap((action) => {
+            if (!action || typeof action !== 'object')
+                return [];
+            const item = action;
+            return [item.name, item.tag, item.description];
+        }),
+        ...webhooks.flatMap((webhook) => {
+            if (!webhook || typeof webhook !== 'object')
+                return [];
+            const item = webhook;
+            return [item.name, item.tag, item.description];
+        }),
+    ].filter((item) => typeof item === 'string').join(' ').toLowerCase();
+}
+export async function listMarketplaceCategories(ctx) {
+    const result = await client(ctx).getPath('/apps/v1/domains');
+    return unwrapList(result);
+}
+export async function getMarketplaceApp(ctx, tag) {
+    const result = await client(ctx).getPath('/apps/v1/fetch/tag', { tag });
+    return unwrapOne(result);
+}
+export async function searchMarketplaceApps(ctx, opts) {
+    const result = await client(ctx).getPath('/apps/v1/domains/all');
+    const apps = unwrapList(result);
+    const terms = (opts.query ?? '').toLowerCase().split(/\s+/).filter(Boolean);
+    const category = opts.category?.toLowerCase();
+    const filtered = apps.filter((app) => {
+        const text = searchableMarketplaceText(app);
+        if (terms.length > 0 && !terms.every((term) => text.includes(term)))
+            return false;
+        if (!category)
+            return true;
+        if (!app || typeof app !== 'object')
+            return false;
+        const domains = app.domains;
+        return Array.isArray(domains) && domains.some((domain) => typeof domain === 'string' && domain.toLowerCase().includes(category));
+    });
+    return filtered.slice(0, Math.max(1, Math.min(opts.limit ?? 20, 100)));
+}
 export async function listCloudTiers(ctx, q) {
     const params = workspaceAuthQuery(ctx);
     if (q.provider)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ductape/cli",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Ductape CLI — local platform, login, link projects, and manage resources via the proxy (Workbench-compatible)",
   "type": "module",
   "main": "dist/index.js",