@postplus/cli 0.1.27 → 0.1.29

package/README.md

@@ -24,7 +24,7 @@ PostPlus has three public surfaces that work together:
 
 - `https://postplus.io/`: the hosted product surface for account access, subscription state, and cloud-backed capabilities.
 - `https://github.com/PostPlusAI/postplus-skills`: the public skill repository that installs local marketing workflows into agent tools.
-- `https://github.com/PostPlusAI/postplus-cli`: the local command-line tool that signs you in, checks local readiness, and connects released skills to PostPlus account state.
+- `https://github.com/PostPlusAI/postplus-cli`: the local command-line tool that signs you in, checks local readiness, confirms high-credit hosted requests, and connects released skills to PostPlus account state.
 
 ## Install
 
@@ -34,6 +34,7 @@ Requires Node.js and npm.
 npm install -g @postplus/cli@latest
 postplus auth login
 npx -y skills add PostPlusAI/postplus-skills --global --full-depth --skill '*' --agent claude-code codex cursor github-copilot windsurf trae trae-cn --yes
+postplus skills verify
 ```
 
 Useful checks:

package/build/doctor.js

@@ -2,6 +2,7 @@ import { resolveFreshRemoteAuth, } from './auth-session.js';
 import { buildPostPlusClientCompatibilityHeaders, formatPostPlusCompatibilityError, } from './client-compatibility.js';
 import { resolveHostedBaseUrl } from './hosted-release.js';
 import { formatLocalDependencyReport, generateLocalDependencyReport, } from './local-dependencies.js';
+import { loadPublicSkillCatalog, } from './skill-catalog.js';
 import { readSubscriptionStatusField } from './subscription-status.js';
 function createPass(id, label, detail, severity = 'required') {
     return {
@@ -23,12 +24,16 @@ function createFail(id, label, detail, fix, input = {}) {
         metadata: input.metadata,
     };
 }
-export async function generateDoctorReport() {
+export async function generateDoctorReport(options = {}) {
     const hostedBaseUrl = await resolveHostedBaseUrl();
     const checks = [
         createPass('hosted_base_url', 'PostPlus Cloud', `Using ${hostedBaseUrl ?? 'https://postplus.io'}`),
     ];
-    checks.push(await checkLocalDependencies());
+    const skillScope = await resolveSkillScope(options.skillId);
+    if (skillScope) {
+        checks.push(createPass('skill_catalog', 'Skill selection', `Using ${skillScope.skill.skillId} from catalog ${skillScope.catalog.releaseId}`));
+    }
+    checks.push(await checkLocalDependencies(skillScope));
     if (!hostedBaseUrl) {
         checks.push(createFail('remote_auth', 'Remote auth', 'PostPlus Cloud base URL could not be resolved.', 'Configure POSTPLUS_API_BASE_URL or run `postplus auth login`.'));
         return buildDoctorReport(checks);
@@ -46,17 +51,40 @@ export async function generateDoctorReport() {
     const authCheck = await checkRemoteAuth(auth);
     checks.push(authCheck);
     if (authCheck.status === 'pass') {
-        checks.push(await checkHostedCapabilities(auth));
+        checks.push(await checkHostedCapabilities(auth, skillScope));
+    }
+    return buildDoctorReport(checks, options.skillId);
+}
+async function resolveSkillScope(skillId) {
+    if (!skillId) {
+        return null;
+    }
+    const catalog = await loadPublicSkillCatalog();
+    const skill = catalog.skills.find((entry) => entry.skillId === skillId);
+    if (!skill) {
+        throw new Error(`Unknown PostPlus skill: ${skillId}. Run \`postplus list\` to see released skill ids.`);
     }
-    return buildDoctorReport(checks);
+    return { catalog, skill };
 }
-async function checkLocalDependencies() {
+async function checkLocalDependencies(skillScope) {
     try {
-        const report = await generateLocalDependencyReport();
+        const report = await generateLocalDependencyReport(skillScope
+            ? {
+                loadCatalog: async () => ({
+                    ...skillScope.catalog,
+                    skills: [skillScope.skill],
+                }),
+            }
+            : {});
         const detail = formatLocalDependencyReport(report);
         if (!report.ok) {
-            return createFail('local_dependencies', 'Task-specific local media dependencies', detail, 'Run the affected PostPlus skill in a local agent. The installed postplus-shared rules tell the agent how to bootstrap approved missing media dependencies.', {
-                severity: 'task_specific',
+            const skillId = skillScope?.skill.skillId;
+            return createFail('local_dependencies', skillId
+                ? `Local dependencies for ${skillId}`
+                : 'Task-specific local media dependencies', detail, skillId
+                ? 'Run the selected PostPlus skill in a local agent. The installed postplus-shared rules tell the agent how to bootstrap approved missing dependencies.'
+                : 'Run the affected PostPlus skill in a local agent. The installed postplus-shared rules tell the agent how to bootstrap approved missing media dependencies.', {
+                severity: skillId ? 'required' : 'task_specific',
                 metadata: {
                     bootstrapRule: 'postplus-shared',
                     missingDependencies: report.checks
@@ -69,7 +97,9 @@ async function checkLocalDependencies() {
                 },
             });
         }
-        return createPass('local_dependencies', 'Local dependencies', detail);
+        return createPass('local_dependencies', skillScope
+            ? `Local dependencies for ${skillScope.skill.skillId}`
+            : 'Local dependencies', detail);
     }
     catch (error) {
         return createFail('local_dependencies', 'Local dependencies', error instanceof Error
@@ -77,13 +107,14 @@ async function checkLocalDependencies() {
             : 'Failed to check local dependencies.');
     }
 }
-function buildDoctorReport(checks) {
+function buildDoctorReport(checks, skillId) {
     const requiredOk = checks.every((check) => check.severity !== 'required' || check.status === 'pass');
     return {
         schemaVersion: 1,
         ok: checks.every((check) => check.status === 'pass'),
         requiredOk,
         checks,
+        ...(skillId ? { skillId } : {}),
     };
 }
 async function checkRemoteAuth(input) {
@@ -114,7 +145,7 @@ async function checkRemoteAuth(input) {
             : 'Failed to validate PostPlus Cloud auth.', 'Run `postplus auth validate` after confirming network access.');
     }
 }
-async function checkHostedCapabilities(input) {
+async function checkHostedCapabilities(input, skillScope) {
     try {
         let response = await requestWithAuth(input, '/api/postplus-cli/hosted/readiness');
         if (response.status === 401) {
@@ -127,17 +158,28 @@ async function checkHostedCapabilities(input) {
         if (!response.ok) {
             return createFail('hosted_capabilities', 'Hosted capabilities', readErrorMessage(payload, 'PostPlus Cloud hosted readiness check failed.'));
         }
-        const capabilities = Array.isArray(payload.capabilities)
-            ? payload.capabilities
-            : [];
-        const failedLabels = capabilities
-            .map(readCapabilityFailureLabel)
+        const capabilities = readHostedCapabilityEntries(payload.capabilities);
+        const relevantCapabilities = skillScope
+            ? filterCapabilitiesForSkill(capabilities, skillScope.skill.requirements)
+            : capabilities;
+        const failedLabels = relevantCapabilities
+            .map((value) => readCapabilityFailureLabel(value, skillScope))
             .filter((value) => value !== null);
-        if (payload.ok !== true || failedLabels.length > 0) {
-            return createFail('hosted_capabilities', 'Hosted capabilities', `Not ready: ${failedLabels.join(', ') || 'unknown capability failure'}`, 'Check PostPlus Cloud provider configuration and subscription state.');
+        if (skillScope && hasHostedRequirements(skillScope.skill.requirements)) {
+            const missingRequirements = collectMissingHostedRequirementLabels(relevantCapabilities, skillScope.skill.requirements);
+            failedLabels.push(...missingRequirements);
+        }
+        if (failedLabels.length > 0 ||
+            (!skillScope && payload.ok !== true && capabilities.length === 0)) {
+            const skillId = skillScope?.skill.skillId;
+            return createFail('hosted_capabilities', skillId ? `Hosted capabilities for ${skillId}` : 'Hosted capabilities', `Not ready: ${failedLabels.join(', ') || 'unknown capability failure'}`, 'Check PostPlus Cloud provider configuration and subscription state.', {
+                severity: skillId ? 'required' : 'task_specific',
+            });
         }
         const subscription = readSubscriptionStatusField(payload).label;
-        return createPass('hosted_capabilities', 'Hosted capabilities', `Ready (${capabilities.length} capability checks passed; subscription ${subscription})`);
+        return createPass('hosted_capabilities', skillScope
+            ? `Hosted capabilities for ${skillScope.skill.skillId}`
+            : 'Hosted capabilities', `Ready (${relevantCapabilities.length} capability checks passed; subscription ${subscription})`);
     }
     catch (error) {
         return createFail('hosted_capabilities', 'Hosted capabilities', error instanceof Error
@@ -145,7 +187,13 @@ async function checkHostedCapabilities(input) {
             : 'Failed to check hosted capability readiness.');
     }
 }
-function readCapabilityFailureLabel(value) {
+function readHostedCapabilityEntries(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((entry) => !!entry && typeof entry === 'object' && !Array.isArray(entry));
+}
+function readCapabilityFailureLabel(value, skillScope) {
     if (!value || typeof value !== 'object') {
         return 'invalid capability response';
     }
@@ -163,9 +211,12 @@ function readCapabilityFailureLabel(value) {
             .map(readReadinessCheckFailureLabel)
             .filter((check) => check !== null)
         : [];
-    return failedChecks.length > 0
+    const labelWithFailures = failedChecks.length > 0
         ? `${label} (${failedChecks.join(', ')})`
         : label;
+    return skillScope
+        ? `${labelWithFailures} for ${skillScope.skill.skillId}`
+        : labelWithFailures;
 }
 function readReadinessCheckFailureLabel(value) {
     if (!value || typeof value !== 'object') {
@@ -181,6 +232,128 @@ function readReadinessCheckFailureLabel(value) {
             ? record.id
             : 'unknown check';
 }
+function filterCapabilitiesForSkill(capabilities, requirements) {
+    if (!hasHostedRequirements(requirements)) {
+        return [];
+    }
+    return capabilities.filter((capability) => capabilityMatchesRequirements(capability, requirements));
+}
+function capabilityMatchesRequirements(capability, requirements) {
+    const identifiers = collectCapabilityIdentifiers(capability);
+    const hostedCapabilities = new Set(requirements.hostedCapabilities);
+    const requirementKeys = collectHostedRequirementKeys(requirements);
+    return identifiers.some((identifier) => {
+        if (identifier === 'media-file:upload' &&
+            hostedCapabilities.has('media-file') &&
+            !requiresHostedMediaFileUpload(requirements)) {
+            return false;
+        }
+        const [prefix, suffix] = splitCapabilityIdentifier(identifier);
+        if (prefix === 'media-file' &&
+            suffix &&
+            suffix !== 'upload' &&
+            hostedCapabilities.has('media-file')) {
+            return true;
+        }
+        if (hostedCapabilities.has(identifier)) {
+            return true;
+        }
+        if (prefix &&
+            suffix &&
+            hostedCapabilities.has(prefix) &&
+            requirementKeys.has(suffix)) {
+            return true;
+        }
+        return requirementKeys.has(identifier) || requirementKeys.has(suffix);
+    });
+}
+function requiresHostedMediaFileUpload(requirements) {
+    return (requirements.hostedCapabilities.includes('media-generation') ||
+        requirements.endpointKeys.length > 0);
+}
+function collectCapabilityIdentifiers(capability) {
+    const identifiers = new Set();
+    for (const key of [
+        'id',
+        'key',
+        'capability',
+        'capabilityKey',
+        'collectionKey',
+        'endpointKey',
+        'modelKey',
+        'sourceKey',
+        'accountConnection',
+    ]) {
+        const value = capability[key];
+        if (typeof value === 'string' && value.trim()) {
+            identifiers.add(value.trim());
+        }
+    }
+    if (Array.isArray(capability.checks)) {
+        for (const check of capability.checks) {
+            if (!check || typeof check !== 'object' || Array.isArray(check)) {
+                continue;
+            }
+            for (const identifier of collectCapabilityIdentifiers(check)) {
+                identifiers.add(identifier);
+            }
+        }
+    }
+    return [...identifiers];
+}
+function collectHostedRequirementKeys(requirements) {
+    return new Set([
+        ...requirements.accountConnections,
+        ...requirements.collectionKeys,
+        ...requirements.endpointKeys,
+        ...requirements.modelKeys,
+        ...requirements.sourceKeys,
+    ]);
+}
+function hasHostedRequirements(requirements) {
+    return (requirements.accountConnections.length > 0 ||
+        requirements.collectionKeys.length > 0 ||
+        requirements.endpointKeys.length > 0 ||
+        requirements.hostedCapabilities.length > 0 ||
+        requirements.modelKeys.length > 0 ||
+        requirements.sourceKeys.length > 0);
+}
+function collectMissingHostedRequirementLabels(capabilities, requirements) {
+    const availableIdentifiers = new Set(capabilities.flatMap(collectCapabilityIdentifiers));
+    const missing = [];
+    for (const capability of requirements.hostedCapabilities) {
+        if (![...availableIdentifiers].some((identifier) => identifierMatchesCapability(identifier, capability))) {
+            missing.push(capability);
+        }
+    }
+    for (const key of collectHostedRequirementKeys(requirements)) {
+        if (![...availableIdentifiers].some((identifier) => identifierMatchesKey(identifier, key))) {
+            missing.push(key);
+        }
+    }
+    return missing.map((value) => `${value} readiness check missing`);
+}
+function identifierMatchesKey(identifier, key) {
+    if (identifier === key) {
+        return true;
+    }
+    const [, suffix] = splitCapabilityIdentifier(identifier);
+    return suffix === key;
+}
+function identifierMatchesCapability(identifier, capability) {
+    if (identifier === capability) {
+        return true;
+    }
+    const [prefix] = splitCapabilityIdentifier(identifier);
+    return prefix === capability;
+}
+function splitCapabilityIdentifier(identifier) {
+    const index = identifier.indexOf(':');
+    if (index === -1) {
+        return [null, identifier];
+    }
+    return [identifier.slice(0, index), identifier.slice(index + 1)];
+}
 function readErrorMessage(payload, fallback) {
     const compatibilityError = formatPostPlusCompatibilityError(payload);
     if (compatibilityError) {

package/build/index.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { readFile } from 'node:fs/promises';
 import { formatAuthRefreshReport, refreshRemoteAuth, revokeRemoteAuthAndReport, } from './auth-lifecycle.js';
 import { loginWithCloudHandoff } from './auth-login.js';
 import { formatAuthValidateReport, validateRemoteAuth, } from './auth-validate.js';
@@ -6,8 +7,9 @@ import { clearAuthState, formatAuthStatusReport, generateAuthStatusReport, } fro
 import { readCurrentCliVersion } from './client-compatibility.js';
 import { formatDoctorReport, generateDoctorReport } from './doctor.js';
 import { assertConfigFilePermissions } from './local-state.js';
+import { readLargeCreditQuoteConfirmationChallenge, resolveLargeCreditQuoteConfirmation, } from './quote-confirmation.js';
 import { POSTPLUS_SKILLS_INSTALL_COMMAND, loadPublicSkillCatalog, } from './skill-catalog.js';
-import { runPostPlusSkillUninstall, runPostPlusSkillUpdate, } from './skill-management.js';
+import { formatSkillBaselineVerifyReport, runPostPlusSkillUninstall, runPostPlusSkillUpdate, runPostPlusSkillVerify, } from './skill-management.js';
 import { formatStatusReport, generateStatusReport } from './status.js';
 import { refreshUpdateCheckCache, runCliSelfUpdateIfOutdated, } from './update-check.js';
 function printAuthHelp() {
@@ -37,27 +39,32 @@ Usage:
   postplus auth status [--json]
   postplus auth validate [--json]
   postplus auth logout [--json]
-  postplus doctor [--json]
+  postplus doctor [--skill <skill-id>] [--json]
+  postplus quote confirm --json --challenge-file <path>
+  postplus skills verify [--json]
   postplus update
   postplus uninstall
   postplus list [--json]
-  postplus status [--json]
+  postplus status [--skill <skill-id>] [--json]
   postplus version
   postplus help
 
 Skills:
   ${POSTPLUS_SKILLS_INSTALL_COMMAND}
+
+After first install, run:
+  postplus skills verify
 `);
 }
-async function runDoctor(json) {
-    const report = await generateDoctorReport();
-    if (json) {
+async function runDoctor(options) {
+    const report = await generateDoctorReport({ skillId: options.skillId });
+    if (options.json) {
         writeJson(report);
     }
     else {
         process.stdout.write(`${formatDoctorReport(report)}\n`);
     }
-    return report.ok ? 0 : 1;
+    return report.requiredOk ? 0 : 1;
 }
 async function runAuthStatus(json) {
     const report = await generateAuthStatusReport();
@@ -69,9 +76,9 @@ async function runAuthStatus(json) {
     }
     return report.ok ? 0 : 1;
 }
-async function runStatus(json) {
-    const report = await generateStatusReport();
-    if (json) {
+async function runStatus(options) {
+    const report = await generateStatusReport({ skillId: options.skillId });
+    if (options.json) {
         writeJson(report);
     }
     else {
@@ -116,9 +123,116 @@ async function runSkillUpdateCommand() {
 async function runSkillUninstallCommand() {
     return runPostPlusSkillUninstall();
 }
+async function runSkillsCommand(rest) {
+    const [subcommand] = rest;
+    switch (subcommand) {
+        case 'verify': {
+            const options = rest.slice(1);
+            const unknownOption = options.find((option) => option !== '--json');
+            if (unknownOption) {
+                process.stderr.write(`Unknown option for skills verify: ${unknownOption}\n`);
+                return 1;
+            }
+            const report = await runPostPlusSkillVerify();
+            if (options.includes('--json')) {
+                writeJson(report);
+            }
+            else {
+                process.stdout.write(`${formatSkillBaselineVerifyReport(report)}\n`);
+            }
+            return report.ok ? 0 : 1;
+        }
+        case 'help':
+        case '--help':
+        case '-h':
+        case undefined:
+            process.stdout.write(`PostPlus CLI — skills commands
+
+Usage:
+  postplus skills verify [--json]  Verify installed public skills and record the managed baseline
+
+Options:
+  --json    Output results as JSON
+`);
+            return 0;
+        default:
+            process.stderr.write(`Unknown skills command: ${subcommand}\n`);
+            return 1;
+    }
+}
+async function runQuoteCommand(rest) {
+    const [subcommand, ...options] = rest;
+    if (subcommand !== 'confirm') {
+        process.stderr.write(`Unknown quote command: ${subcommand ?? ''}\n`);
+        return 1;
+    }
+    const parsed = parseQuoteConfirmOptions(options);
+    if (!parsed.json) {
+        process.stderr.write('quote confirm requires --json.\n');
+        return 1;
+    }
+    if (!parsed.challengeFile) {
+        process.stderr.write('quote confirm requires --challenge-file.\n');
+        return 1;
+    }
+    const challenge = readLargeCreditQuoteConfirmationChallenge(JSON.parse(await readFile(parsed.challengeFile, 'utf8')));
+    if (!challenge) {
+        process.stderr.write('Invalid large credit quote confirmation challenge.\n');
+        return 1;
+    }
+    writeJson(await resolveLargeCreditQuoteConfirmation(challenge));
+    return 0;
+}
+function parseQuoteConfirmOptions(args) {
+    const options = {
+        challengeFile: null,
+        json: false,
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--json') {
+            options.json = true;
+            continue;
+        }
+        if (arg === '--challenge-file') {
+            const challengeFile = args[index + 1];
+            if (!challengeFile || challengeFile.startsWith('--')) {
+                throw new Error('Missing value for --challenge-file.');
+            }
+            options.challengeFile = challengeFile;
+            index += 1;
+            continue;
+        }
+        throw new Error(`Unknown option for quote confirm: ${arg}`);
+    }
+    return options;
+}
 function writeJson(value) {
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
+function parseDiagnosticOptions(args) {
+    const options = {
+        json: false,
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--json') {
+            options.json = true;
+            continue;
+        }
+        if (arg === '--skill') {
+            const skillId = args[index + 1];
+            if (!skillId || skillId.startsWith('--')) {
+                throw new Error('Missing value for --skill.');
+            }
+            options.skillId = skillId;
+            index += 1;
+            continue;
+        }
+        throw new Error(`Unknown option for diagnostics command: ${arg}`);
+    }
+    return options;
+}
 async function runAuthLogout(json) {
     const report = await clearAuthState();
     if (json) {
@@ -192,6 +306,9 @@ async function main() {
             if (helpTopic === 'auth') {
                 printAuthHelp();
             }
+            else if (helpTopic === 'skills') {
+                await runSkillsCommand(['help']);
+            }
             else {
                 printHelp();
             }
@@ -199,7 +316,13 @@ async function main() {
             return;
         }
         case 'doctor':
-            process.exitCode = await runDoctor(json);
+            process.exitCode = await runDoctor(parseDiagnosticOptions(rest));
+            return;
+        case 'quote':
+            process.exitCode = await runQuoteCommand(rest);
+            return;
+        case 'skills':
+            process.exitCode = await runSkillsCommand(rest);
             return;
         case 'install':
             process.stderr.write(`PostPlus CLI does not install skills directly. Run \`${POSTPLUS_SKILLS_INSTALL_COMMAND}\`.\n`);
@@ -215,7 +338,7 @@ async function main() {
             process.exitCode = await runList(json);
             return;
         case 'status':
-            process.exitCode = await runStatus(json);
+            process.exitCode = await runStatus(parseDiagnosticOptions(rest));
             return;
         case 'auth': {
             const [subcommand, ...authRest] = rest;

package/build/quote-confirmation.js

@@ -0,0 +1,163 @@
+import readline from 'node:readline/promises';
+import { readLocalConfig, updateLocalConfig } from './local-state.js';
+const PRODUCT_ERROR_CODE = 'postplus_cli_quote_confirmation_required';
+export function readLargeCreditQuoteConfirmationChallenge(value) {
+    if (!value || typeof value !== 'object') {
+        return null;
+    }
+    const record = value;
+    const challenge = record.productErrorCode === PRODUCT_ERROR_CODE
+        ? record.quoteConfirmation
+        : record.quoteConfirmation && typeof record.quoteConfirmation === 'object'
+            ? record.quoteConfirmation
+            : value;
+    if (!challenge || typeof challenge !== 'object') {
+        return null;
+    }
+    const parsed = challenge;
+    if (typeof parsed.accountId !== 'string' ||
+        typeof parsed.action !== 'string' ||
+        typeof parsed.estimatedMillicredits !== 'number' ||
+        typeof parsed.featureLabel !== 'string' ||
+        typeof parsed.operationId !== 'string' ||
+        typeof parsed.requiredTierMillicredits !== 'number' ||
+        typeof parsed.reservedMillicredits !== 'number' ||
+        typeof parsed.serviceLabel !== 'string' ||
+        typeof parsed.token !== 'string') {
+        return null;
+    }
+    return {
+        accountId: parsed.accountId,
+        action: parsed.action,
+        billingUnit: typeof parsed.billingUnit === 'string' ? parsed.billingUnit : undefined,
+        drivers: parseDrivers(parsed.drivers),
+        estimatedCredits: typeof parsed.estimatedCredits === 'number'
+            ? parsed.estimatedCredits
+            : undefined,
+        estimatedMillicredits: parsed.estimatedMillicredits,
+        estimatedOnly: parsed.estimatedOnly === true,
+        featureLabel: parsed.featureLabel,
+        operationId: parsed.operationId,
+        requiredTierCredits: typeof parsed.requiredTierCredits === 'number'
+            ? parsed.requiredTierCredits
+            : undefined,
+        requiredTierMillicredits: parsed.requiredTierMillicredits,
+        reservedCredits: typeof parsed.reservedCredits === 'number'
+            ? parsed.reservedCredits
+            : undefined,
+        reservedMillicredits: parsed.reservedMillicredits,
+        serviceLabel: parsed.serviceLabel,
+        token: parsed.token,
+    };
+}
+export async function resolveLargeCreditQuoteConfirmation(challenge, dependencies = {
+    confirm: confirmLargeCreditQuote,
+}) {
+    const acknowledgedTierMillicredits = await readAcknowledgedTierMillicredits(challenge);
+    if (acknowledgedTierMillicredits < challenge.requiredTierMillicredits) {
+        await dependencies.confirm(challenge);
+        await writeAcknowledgedTierMillicredits(challenge);
+    }
+    return {
+        schemaVersion: 1,
+        token: challenge.token,
+    };
+}
+export async function confirmLargeCreditQuote(challenge) {
+    const terminal = readline.createInterface({
+        input: process.stdin,
+        output: process.stderr,
+    });
+    try {
+        const answer = await terminal.question(buildLargeCreditConfirmationPrompt(challenge));
+        if (answer.trim() !== 'CONFIRM') {
+            throw new Error('Large credit charge was not confirmed.');
+        }
+    }
+    finally {
+        terminal.close();
+    }
+}
+export function buildLargeCreditConfirmationPrompt(challenge) {
+    const lines = [
+        '',
+        'PostPlus large credit warning',
+        `This request crosses the ${formatCredits(challenge.requiredTierMillicredits)}-credit warning tier.`,
+        `Estimated charge: ${formatCredits(challenge.estimatedMillicredits)} credits${challenge.estimatedOnly ? ' (estimate)' : ''}.`,
+        `Reserved before execution: ${formatCredits(challenge.reservedMillicredits)} credits.`,
+        `Capability: ${formatText(challenge.featureLabel)} / ${formatText(challenge.action)}.`,
+        `Service: ${formatText(challenge.serviceLabel)}.`,
+    ];
+    const drivers = Array.isArray(challenge.drivers)
+        ? challenge.drivers.filter((driver) => {
+            return (driver &&
+                typeof driver === 'object' &&
+                typeof driver.label === 'string' &&
+                driver.value !== undefined &&
+                driver.value !== null);
+        })
+        : [];
+    if (drivers.length > 0) {
+        lines.push('High-credit drivers:');
+        for (const driver of drivers.slice(0, 8)) {
+            lines.push(`- ${driver.label}: ${String(driver.value)}`);
+        }
+    }
+    lines.push('PostPlus will warn again only when a future request crosses a higher tier.', 'Type CONFIRM to continue: ');
+    return lines.join('\n');
+}
+async function readAcknowledgedTierMillicredits(challenge) {
+    const config = await readLocalConfig();
+    const tier = config?.largeCreditConfirmation?.acknowledgedTierMillicreditsByAccountId?.[challenge.accountId];
+    return typeof tier === 'number' && Number.isSafeInteger(tier) && tier > 0
+        ? tier
+        : 0;
+}
+async function writeAcknowledgedTierMillicredits(challenge) {
+    await updateLocalConfig((current) => {
+        const config = current ?? {};
+        const largeCreditConfirmation = config.largeCreditConfirmation ?? {};
+        const currentTiers = largeCreditConfirmation.acknowledgedTierMillicreditsByAccountId ?? {};
+        const previousTier = currentTiers[challenge.accountId];
+        return {
+            ...config,
+            largeCreditConfirmation: {
+                ...largeCreditConfirmation,
+                acknowledgedTierMillicreditsByAccountId: {
+                    ...currentTiers,
+                    [challenge.accountId]: Math.max(typeof previousTier === 'number' &&
+                        Number.isSafeInteger(previousTier)
+                        ? previousTier
+                        : 0, challenge.requiredTierMillicredits),
+                },
+            },
+        };
+    });
+}
+function parseDrivers(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .filter((driver) => {
+        return Boolean(driver) && typeof driver === 'object';
+    })
+        .filter((driver) => typeof driver.label === 'string')
+        .map((driver) => ({
+        key: typeof driver.key === 'string' ? driver.key : undefined,
+        label: driver.label,
+        value: driver.value,
+    }));
+}
+function formatText(value) {
+    return value.trim() ? value : 'unknown';
+}
+function formatCredits(millicredits) {
+    const credits = millicredits / 1_000;
+    if (!Number.isFinite(credits)) {
+        return 'unknown';
+    }
+    return Number.isInteger(credits)
+        ? String(credits)
+        : credits.toFixed(3).replace(/0+$/, '').replace(/\.$/, '');
+}

package/build/skill-catalog.js

@@ -15,6 +15,15 @@ export const POSTPLUS_SKILLS_INSTALL_COMMAND = formatPostPlusSkillsInstallComman
 export const POSTPLUS_SKILLS_LIST_COMMAND = formatPostPlusSkillsListCommand();
 const POSTPLUS_SKILLS_INDEX_URL = 'https://raw.githubusercontent.com/PostPlusAI/postplus-skills/main/skills/INDEX.md';
 const POSTPLUS_SKILLS_CATALOG_URL = 'https://raw.githubusercontent.com/PostPlusAI/postplus-skills/main/skills/catalog.json';
+export const PUBLIC_SKILL_REQUIREMENT_KEYS = [
+    'accountConnections',
+    'collectionKeys',
+    'endpointKeys',
+    'hostedCapabilities',
+    'localDependencies',
+    'modelKeys',
+    'sourceKeys',
+];
 export async function loadPublicSkillCatalog(fetchFn = fetch, env = process.env) {
     const catalogUrl = resolvePostPlusSkillsCatalogUrl(env);
     const skillsSource = resolvePostPlusSkillsSource(env);
@@ -95,17 +104,7 @@ function parsePublicSkillCatalog(payload) {
         const path = typeof skill.path === 'string' && skill.path.trim()
             ? skill.path.trim()
             : null;
-        const requirements = skill.requirements &&
-            typeof skill.requirements === 'object' &&
-            !Array.isArray(skill.requirements)
-            ? skill.requirements
-            : {};
-        const localDependencies = Array.isArray(requirements.localDependencies)
-            ? requirements.localDependencies
-                .filter((value) => typeof value === 'string')
-                .map((value) => value.trim())
-                .filter(Boolean)
-            : [];
+        const requirements = parsePublicSkillRequirements(skill.requirements);
         const status = typeof skill.status === 'string' ? skill.status.trim() : '';
         if (!skillId ||
             !path ||
@@ -113,9 +112,10 @@ function parsePublicSkillCatalog(payload) {
             throw new Error('PostPlus public skill catalog has an invalid skill.');
         }
         return {
-            localDependencies,
+            localDependencies: requirements.localDependencies,
             skillId,
             path,
+            requirements,
         };
     });
     if (skills.length === 0) {
@@ -127,3 +127,40 @@ function parsePublicSkillCatalog(payload) {
         source,
     };
 }
+function parsePublicSkillRequirements(value) {
+    if (value === undefined) {
+        return createEmptyRequirements();
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('PostPlus public skill catalog has invalid skill requirements.');
+    }
+    const record = value;
+    const requirements = createEmptyRequirements();
+    for (const key of PUBLIC_SKILL_REQUIREMENT_KEYS) {
+        const raw = record[key];
+        if (raw === undefined) {
+            continue;
+        }
+        if (!Array.isArray(raw)) {
+            throw new Error(`PostPlus public skill catalog has invalid ${key} requirements.`);
+        }
+        requirements[key] = raw.map((item) => {
+            if (typeof item !== 'string' || !item.trim()) {
+                throw new Error(`PostPlus public skill catalog has invalid ${key} requirements.`);
+            }
+            return item.trim();
+        });
+    }
+    return requirements;
+}
+function createEmptyRequirements() {
+    return {
+        accountConnections: [],
+        collectionKeys: [],
+        endpointKeys: [],
+        hostedCapabilities: [],
+        localDependencies: [],
+        modelKeys: [],
+        sourceKeys: [],
+    };
+}

package/build/skill-management.js

@@ -49,8 +49,38 @@ export async function runPostPlusSkillUninstall(dependencies = {
 export async function generateSkillInstallStatusReport(dependencies = {
     runCommand,
 }) {
+    return (await inspectPostPlusSkillInstall(dependencies)).report;
+}
+export async function runPostPlusSkillVerify(dependencies = {
+    runCommand,
+}) {
+    const inspection = await inspectPostPlusSkillInstall(dependencies);
+    const previousManagedSkillsReleaseId = inspection.report.managedSkillsReleaseId;
+    if (!inspection.report.ok) {
+        return {
+            ...inspection.report,
+            baselineUpdated: false,
+            previousManagedSkillsReleaseId,
+            verifiedSkillsReleaseId: null,
+        };
+    }
+    await writeManagedSkillBaseline({
+        releaseId: inspection.catalog.releaseId,
+        skillNames: inspection.requiredSkillNames,
+    });
+    await writeCurrentCliVersionToLocalConfig();
+    return {
+        ...inspection.report,
+        baselineUpdated: true,
+        managedSkillsReleaseId: inspection.catalog.releaseId,
+        previousManagedSkillsReleaseId,
+        verifiedSkillsReleaseId: inspection.catalog.releaseId,
+    };
+}
+async function inspectPostPlusSkillInstall(dependencies) {
     const catalog = await loadPublicSkillCatalog();
-    const requiredSkills = new Set(catalog.skills.map((skill) => skill.skillId));
+    const requiredSkillNames = catalog.skills.map((skill) => skill.skillId);
+    const requiredSkills = new Set(requiredSkillNames);
     const baseline = await readManagedSkillBaseline();
     const retiredManagedSkills = baseline.skillNames.filter((skillName) => !requiredSkills.has(skillName));
     try {
@@ -64,36 +94,44 @@ export async function generateSkillInstallStatusReport(dependencies = {
                 .filter((scope) => scope.trim().length > 0)),
         ].sort();
         return {
-            ok: missingSkills.length === 0,
-            error: null,
-            installCommand: formatPostPlusSkillsInstallCommand(catalog.source),
-            installedCount: installedNames.size,
-            managedSkillsReleaseId: baseline.releaseId,
-            missingSkills,
-            requiredCount: requiredSkills.size,
-            retiredManagedSkills,
-            scopes,
-            source: catalog.source,
-            updateCommand: formatPostPlusSkillUpdateCommand(),
-            uninstallCommand: formatPostPlusSkillUninstallCommand(),
+            catalog,
+            report: {
+                ok: missingSkills.length === 0,
+                error: null,
+                installCommand: formatPostPlusSkillsInstallCommand(catalog.source),
+                installedCount: installedNames.size,
+                managedSkillsReleaseId: baseline.releaseId,
+                missingSkills,
+                requiredCount: requiredSkills.size,
+                retiredManagedSkills,
+                scopes,
+                source: catalog.source,
+                updateCommand: formatPostPlusSkillUpdateCommand(),
+                uninstallCommand: formatPostPlusSkillUninstallCommand(),
+            },
+            requiredSkillNames,
         };
     }
     catch (error) {
         return {
-            ok: false,
-            error: error instanceof Error
-                ? error.message
-                : 'Failed to inspect installed PostPlus skills.',
-            installCommand: formatPostPlusSkillsInstallCommand(catalog.source),
-            installedCount: 0,
-            managedSkillsReleaseId: baseline.releaseId,
-            missingSkills: [...requiredSkills],
-            requiredCount: requiredSkills.size,
-            retiredManagedSkills,
-            scopes: [],
-            source: catalog.source,
-            updateCommand: formatPostPlusSkillUpdateCommand(),
-            uninstallCommand: formatPostPlusSkillUninstallCommand(),
+            catalog,
+            report: {
+                ok: false,
+                error: error instanceof Error
+                    ? error.message
+                    : 'Failed to inspect installed PostPlus skills.',
+                installCommand: formatPostPlusSkillsInstallCommand(catalog.source),
+                installedCount: 0,
+                managedSkillsReleaseId: baseline.releaseId,
+                missingSkills: [...requiredSkills],
+                requiredCount: requiredSkills.size,
+                retiredManagedSkills,
+                scopes: [],
+                source: catalog.source,
+                updateCommand: formatPostPlusSkillUpdateCommand(),
+                uninstallCommand: formatPostPlusSkillUninstallCommand(),
+            },
+            requiredSkillNames,
         };
     }
 }
@@ -122,6 +160,31 @@ export function formatSkillInstallStatusReport(report) {
     }
     return lines.join('\n');
 }
+export function formatSkillBaselineVerifyReport(report) {
+    const lines = ['PostPlus skills verify', ''];
+    if (report.error) {
+        lines.push(`[FAIL] Skill installer: ${report.error}`);
+    }
+    else if (report.ok) {
+        lines.push(`[PASS] Installed released skills: ${report.installedCount}/${report.requiredCount}`);
+    }
+    else {
+        lines.push(`[FAIL] Installed released skills: ${report.installedCount}/${report.requiredCount}`);
+    }
+    lines.push(`  Source: ${report.source}`);
+    lines.push(`  Previous managed baseline: ${report.previousManagedSkillsReleaseId ?? 'none'}`);
+    if (report.baselineUpdated && report.verifiedSkillsReleaseId) {
+        lines.push(`  Verified baseline: ${report.verifiedSkillsReleaseId}`);
+        lines.push('  Next: postplus status');
+    }
+    else {
+        lines.push('  Verified baseline: unchanged');
+    }
+    if (report.missingSkills.length > 0) {
+        lines.push(`  Missing: ${formatSkillList(report.missingSkills, 8)}`, `  Fix: ${report.installCommand}`);
+    }
+    return lines.join('\n');
+}
 export function buildPostPlusSkillUpdateArgs(skillNames) {
     if (skillNames.length === 0) {
         throw new Error('PostPlus public skill catalog has no released skills.');

package/build/status.js

@@ -3,17 +3,17 @@ import { writeCurrentCliVersionToLocalConfig } from './client-compatibility.js';
 import { formatDoctorReport, generateDoctorReport, } from './doctor.js';
 import { formatSkillInstallStatusReport, generateSkillInstallStatusReport, } from './skill-management.js';
 import { formatUpdateStatusReport, generateUpdateStatusReport, } from './update-check.js';
-export async function generateStatusReport() {
-    return generateStatusReportWithDependencies();
+export async function generateStatusReport(options = {}) {
+    return generateStatusReportWithDependencies({}, options);
 }
-export async function generateStatusReportWithDependencies(dependencies = {}) {
+export async function generateStatusReportWithDependencies(dependencies = {}, options = {}) {
     await writeCurrentCliVersionToLocalConfig();
     const generateAuthStatus = dependencies.generateAuthStatus ?? generateAuthStatusReport;
     const generateDoctor = dependencies.generateDoctor ?? generateDoctorReport;
     const generateSkillStatus = dependencies.generateSkillStatus ?? generateSkillInstallStatusReport;
     const generateUpdateStatus = dependencies.generateUpdateStatus ?? generateUpdateStatusReport;
     const [doctor, auth, skills, updates] = await Promise.all([
-        generateDoctor(),
+        generateDoctor({ skillId: options.skillId }),
         generateAuthStatus(),
         generateSkillStatus(),
         generateUpdateStatus(),
@@ -25,6 +25,7 @@ export async function generateStatusReportWithDependencies(dependencies = {}) {
         auth,
         skills,
         updates,
+        ...(options.skillId ? { skillId: options.skillId } : {}),
     };
 }
 export function formatStatusReport(report) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postplus/cli",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "packageManager": "pnpm@10.30.3+sha512.c961d1e0a2d8e354ecaa5166b822516668b7f44cb5bd95122d590dd81922f606f5473b6d23ec4a5be05e7fcd18e8488d47d978bbe981872f1145d06e9a740017",
   "type": "module",
   "description": "PostPlus CLI for PostPlus Cloud auth, status, and diagnostics.",
@@ -18,6 +18,7 @@
     "build/index.js",
     "build/local-dependencies.js",
     "build/local-state.js",
+    "build/quote-confirmation.js",
     "build/skill-catalog.js",
     "build/skill-management.js",
     "build/status.js",