@postplus/cli 0.1.18 → 0.1.20

package/README.md

@@ -33,7 +33,7 @@ Requires Node.js and npm.
 ```bash
 npm install -g @postplus/cli
 postplus auth login
-npx -y skills add PostPlusAI/postplus-skills --full-depth --skill '*' --agent claude-code codex cursor github-copilot windsurf trae trae-cn --yes
+npx -y skills add PostPlusAI/postplus-skills --global --full-depth --skill '*' --agent claude-code codex cursor github-copilot windsurf trae trae-cn --yes
 ```
 
 Useful checks:

package/build/doctor.js

@@ -1,20 +1,24 @@
 import { resolveFreshRemoteAuth, } from './auth-session.js';
 import { resolveHostedBaseUrl } from './hosted-release.js';
-function createPass(id, label, detail) {
+import { formatLocalDependencyReport, generateLocalDependencyReport, } from './local-dependencies.js';
+function createPass(id, label, detail, severity = 'required') {
     return {
         id,
         label,
         status: 'pass',
+        severity,
         detail,
     };
 }
-function createFail(id, label, detail, fix) {
+function createFail(id, label, detail, fix, input = {}) {
     return {
         id,
         label,
         status: 'fail',
+        severity: input.severity ?? 'required',
         detail,
         fix,
+        metadata: input.metadata,
     };
 }
 export async function generateDoctorReport() {
@@ -22,6 +26,7 @@ export async function generateDoctorReport() {
     const checks = [
         createPass('hosted_base_url', 'PostPlus Cloud', `Using ${hostedBaseUrl ?? 'https://postplus.io'}`),
     ];
+    checks.push(await checkLocalDependencies());
     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);
@@ -43,9 +48,39 @@ export async function generateDoctorReport() {
     }
     return buildDoctorReport(checks);
 }
+async function checkLocalDependencies() {
+    try {
+        const report = await generateLocalDependencyReport();
+        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',
+                metadata: {
+                    bootstrapRule: 'postplus-shared',
+                    missingDependencies: report.checks
+                        .filter((check) => !check.ok)
+                        .map((check) => ({
+                        dependency: check.dependency,
+                        detail: check.detail,
+                        skillIds: check.skillIds,
+                    })),
+                },
+            });
+        }
+        return createPass('local_dependencies', 'Local dependencies', detail);
+    }
+    catch (error) {
+        return createFail('local_dependencies', 'Local dependencies', error instanceof Error
+            ? error.message
+            : 'Failed to check local dependencies.');
+    }
+}
 function buildDoctorReport(checks) {
+    const requiredOk = checks.every((check) => check.severity !== 'required' || check.status === 'pass');
     return {
+        schemaVersion: 1,
         ok: checks.every((check) => check.status === 'pass'),
+        requiredOk,
         checks,
     };
 }
@@ -120,11 +155,33 @@ function readCapabilityFailureLabel(value) {
     if (record.ok === true || record.required === false) {
         return null;
     }
-    return typeof record.label === 'string'
+    const label = typeof record.label === 'string'
         ? record.label
         : typeof record.id === 'string'
             ? record.id
             : 'unknown capability';
+    const failedChecks = Array.isArray(record.checks)
+        ? record.checks
+            .map(readReadinessCheckFailureLabel)
+            .filter((check) => check !== null)
+        : [];
+    return failedChecks.length > 0
+        ? `${label} (${failedChecks.join(', ')})`
+        : label;
+}
+function readReadinessCheckFailureLabel(value) {
+    if (!value || typeof value !== 'object') {
+        return 'invalid readiness check';
+    }
+    const record = value;
+    if (record.ok === true || record.required === false) {
+        return null;
+    }
+    return typeof record.label === 'string'
+        ? record.label
+        : typeof record.id === 'string'
+            ? record.id
+            : 'unknown check';
 }
 function readErrorMessage(payload, fallback) {
     return typeof payload.error === 'string' && payload.error.trim().length > 0
@@ -143,12 +200,20 @@ function requestWithAuth(input, path) {
 export function formatDoctorReport(report) {
     const lines = ['PostPlus CLI doctor', ''];
     for (const check of report.checks) {
-        const marker = check.status === 'pass' ? '[PASS]' : '[FAIL]';
+        const marker = check.status === 'pass'
+            ? '[PASS]'
+            : check.severity === 'task_specific'
+                ? '[WARN]'
+                : '[FAIL]';
         lines.push(`${marker} ${check.label}: ${check.detail}`);
         if (check.fix) {
             lines.push(`  Fix: ${check.fix}`);
         }
     }
-    lines.push('', report.ok ? 'Doctor passed.' : 'Doctor failed.');
+    lines.push('', report.ok
+        ? 'Doctor passed.'
+        : report.requiredOk
+            ? 'Doctor incomplete: task-specific checks need attention.'
+            : 'Doctor failed.');
     return lines.join('\n');
 }

package/build/index.js

@@ -8,7 +8,7 @@ import { assertConfigFilePermissions } from './local-state.js';
 import { POSTPLUS_SKILLS_INSTALL_COMMAND, loadPublicSkillCatalog, } from './skill-catalog.js';
 import { runPostPlusSkillUninstall, runPostPlusSkillUpdate, } from './skill-management.js';
 import { formatStatusReport, generateStatusReport } from './status.js';
-import { refreshUpdateCheckBaseline } from './update-check.js';
+import { readCurrentCliVersion, refreshUpdateCheckCache, } from './update-check.js';
 function printAuthHelp() {
     process.stdout.write(`PostPlus CLI — auth commands
 
@@ -41,6 +41,7 @@ Usage:
   postplus uninstall
   postplus list [--json]
   postplus status [--json]
+  postplus version
   postplus help
 
 Skills:
@@ -96,10 +97,14 @@ async function runList(json) {
     process.stdout.write(`${lines.join('\n')}\n`);
     return 0;
 }
+async function runVersion() {
+    process.stdout.write(`${await readCurrentCliVersion()}\n`);
+    return 0;
+}
 async function runSkillUpdateCommand() {
     const exitCode = await runPostPlusSkillUpdate();
     if (exitCode === 0) {
-        await refreshUpdateCheckBaseline().catch(() => { });
+        await refreshUpdateCheckCache().catch(() => { });
     }
     return exitCode;
 }
@@ -172,6 +177,11 @@ async function main() {
             printHelp();
             process.exitCode = 0;
             return;
+        case '--version':
+        case '-v':
+        case 'version':
+            process.exitCode = await runVersion();
+            return;
         case 'help': {
             const [helpTopic] = rest;
             if (helpTopic === 'auth') {

package/build/local-dependencies.js

@@ -0,0 +1,101 @@
+import { runCommand } from './command-runner.js';
+import { loadPublicSkillCatalog, } from './skill-catalog.js';
+const LOCAL_DEPENDENCY_CHECK_TIMEOUT_MS = 10_000;
+export async function generateLocalDependencyReport(options = {}) {
+    const loadCatalog = options.loadCatalog ?? loadPublicSkillCatalog;
+    const runDependencyCheck = options.runDependencyCheck ?? runLocalDependencyCommand;
+    const catalog = await loadCatalog();
+    const requirements = collectLocalDependencyRequirements(catalog);
+    const checks = await Promise.all(requirements.map(({ dependency, skillIds }) => checkLocalDependency(dependency, skillIds, runDependencyCheck)));
+    return {
+        ok: checks.every((check) => check.ok),
+        revision: catalog.revision,
+        source: catalog.source,
+        requiredCount: checks.length,
+        checks,
+    };
+}
+export function formatLocalDependencyReport(report) {
+    if (report.requiredCount === 0) {
+        return `No local runtime dependencies are required by released PostPlus skills (${report.revision}).`;
+    }
+    const missing = report.checks.filter((check) => !check.ok);
+    if (missing.length === 0) {
+        return `Ready (${report.requiredCount} local dependencies present; catalog ${report.revision})`;
+    }
+    return `Missing ${missing.length}/${report.requiredCount}: ${missing
+        .map((check) => `${check.dependency} for ${formatSkillList(check.skillIds)}`)
+        .join('; ')}`;
+}
+function collectLocalDependencyRequirements(catalog) {
+    const dependencyToSkills = new Map();
+    for (const skill of catalog.skills) {
+        for (const dependency of skill.localDependencies) {
+            if (!dependencyToSkills.has(dependency)) {
+                dependencyToSkills.set(dependency, new Set());
+            }
+            dependencyToSkills.get(dependency)?.add(skill.skillId);
+        }
+    }
+    return [...dependencyToSkills.entries()]
+        .map(([dependency, skillIds]) => ({
+        dependency,
+        skillIds: [...skillIds].sort((a, b) => a.localeCompare(b)),
+    }))
+        .sort((a, b) => a.dependency.localeCompare(b.dependency));
+}
+async function checkLocalDependency(dependency, skillIds, runDependencyCheck) {
+    try {
+        const command = buildLocalDependencyCommand(dependency);
+        await runDependencyCheck(command.command, command.args);
+        return {
+            dependency,
+            ok: true,
+            detail: 'available',
+            skillIds,
+        };
+    }
+    catch (error) {
+        return {
+            dependency,
+            ok: false,
+            detail: error instanceof Error
+                ? error.message
+                : 'Local dependency check failed.',
+            skillIds,
+        };
+    }
+}
+function buildLocalDependencyCommand(dependency) {
+    const parts = dependency.split(':');
+    if (parts.length === 1) {
+        return {
+            command: dependency,
+            args: ['--version'],
+        };
+    }
+    const [runtime, moduleName] = parts;
+    if (parts.length === 2 &&
+        runtime === 'python3' &&
+        /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(moduleName)) {
+        return {
+            command: 'python3',
+            args: [
+                '-c',
+                `import importlib; importlib.import_module(${JSON.stringify(moduleName)})`,
+            ],
+        };
+    }
+    throw new Error(`Unsupported local dependency requirement: ${dependency}`);
+}
+async function runLocalDependencyCommand(command, args) {
+    await runCommand(command, args, {
+        timeoutMs: LOCAL_DEPENDENCY_CHECK_TIMEOUT_MS,
+    });
+}
+function formatSkillList(skillIds) {
+    if (skillIds.length <= 3) {
+        return skillIds.join(', ');
+    }
+    return `${skillIds.slice(0, 3).join(', ')} +${skillIds.length - 3} more`;
+}

package/build/local-state.js

@@ -103,6 +103,41 @@ export async function clearLocalAuthState() {
         return next;
     });
 }
+export async function readManagedSkillBaseline() {
+    const config = await readLocalConfig();
+    const managedSkills = config?.managedSkills;
+    if (!managedSkills ||
+        typeof managedSkills.revision !== 'string' ||
+        !Array.isArray(managedSkills.skillNames)) {
+        return {
+            revision: null,
+            skillNames: [],
+        };
+    }
+    return {
+        revision: managedSkills.revision,
+        skillNames: normalizeSkillNames(managedSkills.skillNames),
+    };
+}
+export async function writeManagedSkillBaseline(input) {
+    return updateLocalConfig((current) => ({
+        ...(current ?? {}),
+        managedSkills: {
+            revision: input.revision,
+            skillNames: normalizeSkillNames(input.skillNames),
+            updatedAt: new Date().toISOString(),
+        },
+    }));
+}
+export async function clearManagedSkillBaseline() {
+    return updateLocalConfig((current) => {
+        const next = {
+            ...(current ?? {}),
+        };
+        delete next.managedSkills;
+        return next;
+    });
+}
 export async function setLocalApiBaseUrl(apiBaseUrl) {
     const normalizedApiBaseUrl = apiBaseUrl.trim();
     if (normalizedApiBaseUrl.length === 0) {
@@ -226,3 +261,6 @@ function omitLegacyAuthFields(current) {
     const { apiKey: _apiKey, machineId: _machineId, ...rest } = (current ?? {});
     return rest;
 }
+function normalizeSkillNames(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))].sort((left, right) => left.localeCompare(right));
+}

package/build/skill-catalog.js

@@ -12,64 +12,101 @@ const POSTPLUS_SKILLS_AGENT_ARGS = POSTPLUS_SKILLS_AGENT_TARGETS.join(' ');
 export const POSTPLUS_SKILLS_INSTALL_COMMAND = `npx -y skills add PostPlusAI/postplus-skills --global --full-depth --skill '*' --agent ${POSTPLUS_SKILLS_AGENT_ARGS} --yes`;
 export const POSTPLUS_SKILLS_LIST_COMMAND = 'npx -y skills add PostPlusAI/postplus-skills --list --full-depth';
 const POSTPLUS_SKILLS_INDEX_URL = 'https://raw.githubusercontent.com/PostPlusAI/postplus-skills/main/skills/INDEX.md';
-export async function loadPublicSkillCatalog() {
-    const response = await fetch(POSTPLUS_SKILLS_INDEX_URL, {
+const POSTPLUS_SKILLS_CATALOG_URL = 'https://raw.githubusercontent.com/PostPlusAI/postplus-skills/main/skills/catalog.json';
+export async function loadPublicSkillCatalog(fetchFn = fetch) {
+    const response = await fetchFn(POSTPLUS_SKILLS_CATALOG_URL, {
         headers: {
-            accept: 'text/markdown,text/plain',
+            accept: 'application/json',
         },
         signal: AbortSignal.timeout(15000),
     });
     if (!response.ok) {
         throw new Error(`Failed to load PostPlus skill catalog (${response.status}): ${response.statusText}`);
     }
-    const indexText = await response.text();
-    const skills = parseSkillIndex(indexText);
-    if (skills.length === 0) {
-        throw new Error('PostPlus public skill catalog is invalid: no released skills were found.');
-    }
+    const raw = await response.text();
+    const payload = parseJsonResponse(raw, POSTPLUS_SKILLS_CATALOG_URL);
+    const catalog = parsePublicSkillCatalog(payload);
     return {
-        source: POSTPLUS_SKILLS_REPO,
+        ...catalog,
+        catalogUrl: POSTPLUS_SKILLS_CATALOG_URL,
         indexUrl: POSTPLUS_SKILLS_INDEX_URL,
         installCommand: POSTPLUS_SKILLS_INSTALL_COMMAND,
         listCommand: POSTPLUS_SKILLS_LIST_COMMAND,
-        skills,
     };
 }
-function parseSkillIndex(indexText) {
-    const skills = [];
-    let inReleasedSkills = false;
-    let sawReleasedSkillsSection = false;
-    let currentSkill = null;
-    for (const line of indexText.split('\n')) {
-        if (line.trim() === '## Released Skills') {
-            inReleasedSkills = true;
-            sawReleasedSkillsSection = true;
-            continue;
-        }
-        if (!inReleasedSkills) {
-            continue;
+function parseJsonResponse(raw, url) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        const trimmed = raw.trimStart();
+        if (trimmed.startsWith('<')) {
+            throw new Error(`PostPlus public skill catalog returned HTML instead of JSON: ${url}`);
         }
-        const skillMatch = line.match(/^- `([^`]+)`\s*$/);
-        if (skillMatch) {
-            currentSkill = skillMatch[1] ?? null;
-            if (currentSkill) {
-                skills.push({
-                    skillId: currentSkill,
-                    path: null,
-                });
-            }
-            continue;
+        throw new Error(error instanceof Error
+            ? `PostPlus public skill catalog returned invalid JSON: ${error.message}`
+            : 'PostPlus public skill catalog returned invalid JSON.');
+    }
+}
+function parsePublicSkillCatalog(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        throw new Error('PostPlus public skill catalog is invalid.');
+    }
+    const record = payload;
+    const revision = typeof record.revision === 'string' && record.revision.trim()
+        ? record.revision.trim()
+        : null;
+    const source = typeof record.source === 'string' && record.source.trim()
+        ? record.source.trim()
+        : null;
+    if (record.schemaVersion !== 1 ||
+        source !== POSTPLUS_SKILLS_REPO ||
+        !revision) {
+        throw new Error('PostPlus public skill catalog metadata is invalid.');
+    }
+    if (!Array.isArray(record.skills)) {
+        throw new Error('PostPlus public skill catalog has no skills array.');
+    }
+    const skills = record.skills.map((value) => {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            throw new Error('PostPlus public skill catalog has an invalid skill.');
         }
-        const pathMatch = line.match(/^\s+- Path: `([^`]+)`\s*$/);
-        if (pathMatch && currentSkill) {
-            const last = skills.at(-1);
-            if (last?.skillId === currentSkill) {
-                last.path = pathMatch[1] ?? null;
-            }
+        const skill = value;
+        const skillId = typeof skill.name === 'string' && skill.name.trim()
+            ? skill.name.trim()
+            : null;
+        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 status = typeof skill.status === 'string' ? skill.status.trim() : '';
+        if (!skillId ||
+            !path ||
+            !(status === 'released' || status.startsWith('released/'))) {
+            throw new Error('PostPlus public skill catalog has an invalid skill.');
         }
+        return {
+            localDependencies,
+            skillId,
+            path,
+        };
+    });
+    if (skills.length === 0) {
+        throw new Error('PostPlus public skill catalog is invalid: no released skills were found.');
     }
-    if (!sawReleasedSkillsSection) {
-        throw new Error('PostPlus public skill catalog is invalid: missing ## Released Skills section.');
-    }
-    return skills;
+    return {
+        revision,
+        skills,
+        source,
+    };
 }

package/build/skill-management.js

@@ -1,27 +1,56 @@
-import { POSTPLUS_SKILLS_AGENT_TARGETS, POSTPLUS_SKILLS_INSTALL_COMMAND, POSTPLUS_SKILLS_REPO, loadPublicSkillCatalog, } from './skill-catalog.js';
 import { runCommand, runInteractiveCommand } from './command-runner.js';
+import { clearManagedSkillBaseline, readManagedSkillBaseline, writeManagedSkillBaseline, } from './local-state.js';
+import { POSTPLUS_SKILLS_AGENT_TARGETS, POSTPLUS_SKILLS_INSTALL_COMMAND, POSTPLUS_SKILLS_REPO, loadPublicSkillCatalog, } from './skill-catalog.js';
 const NPX_SKILLS = ['-y', 'skills'];
-export async function runPostPlusSkillUpdate() {
+export async function runPostPlusSkillUpdate(dependencies = {
+    runInteractiveCommand,
+}) {
     const catalog = await loadPublicSkillCatalog();
     const skillNames = catalog.skills.map((skill) => skill.skillId);
+    const baseline = await readManagedSkillBaseline();
+    const retiredSkillNames = baseline.skillNames.filter((skillName) => !skillNames.includes(skillName));
     if (skillNames.length === 0) {
         throw new Error('PostPlus public skill catalog has no released skills.');
     }
-    return runInteractiveCommand('npx', buildPostPlusSkillUpdateArgs(skillNames));
+    const updateExitCode = await dependencies.runInteractiveCommand('npx', buildPostPlusSkillUpdateArgs(skillNames));
+    if (updateExitCode !== 0) {
+        return updateExitCode;
+    }
+    if (retiredSkillNames.length > 0) {
+        const removeExitCode = await dependencies.runInteractiveCommand('npx', buildPostPlusSkillUninstallArgs(retiredSkillNames));
+        if (removeExitCode !== 0) {
+            return removeExitCode;
+        }
+    }
+    await writeManagedSkillBaseline({
+        revision: catalog.revision,
+        skillNames,
+    });
+    return 0;
 }
-export async function runPostPlusSkillUninstall() {
+export async function runPostPlusSkillUninstall(dependencies = {
+    runInteractiveCommand,
+}) {
     const catalog = await loadPublicSkillCatalog();
     const skillNames = catalog.skills.map((skill) => skill.skillId);
-    if (skillNames.length === 0) {
+    const baseline = await readManagedSkillBaseline();
+    const allKnownSkillNames = mergeSkillNames(skillNames, baseline.skillNames);
+    if (allKnownSkillNames.length === 0) {
         throw new Error('PostPlus public skill catalog has no released skills.');
     }
-    return runInteractiveCommand('npx', buildPostPlusSkillUninstallArgs(skillNames));
+    const exitCode = await dependencies.runInteractiveCommand('npx', buildPostPlusSkillUninstallArgs(allKnownSkillNames));
+    if (exitCode === 0) {
+        await clearManagedSkillBaseline();
+    }
+    return exitCode;
 }
 export async function generateSkillInstallStatusReport(dependencies = {
     runCommand,
 }) {
     const catalog = await loadPublicSkillCatalog();
     const requiredSkills = new Set(catalog.skills.map((skill) => skill.skillId));
+    const baseline = await readManagedSkillBaseline();
+    const retiredManagedSkills = baseline.skillNames.filter((skillName) => !requiredSkills.has(skillName));
     try {
         const installed = await listInstalledSkills(dependencies);
         const postPlusInstalled = installed.filter((skill) => requiredSkills.has(skill.name));
@@ -37,8 +66,10 @@ export async function generateSkillInstallStatusReport(dependencies = {
             error: null,
             installCommand: POSTPLUS_SKILLS_INSTALL_COMMAND,
             installedCount: installedNames.size,
+            managedRevision: baseline.revision,
             missingSkills,
             requiredCount: requiredSkills.size,
+            retiredManagedSkills,
             scopes,
             source: POSTPLUS_SKILLS_REPO,
             updateCommand: formatPostPlusSkillUpdateCommand(),
@@ -53,8 +84,10 @@ export async function generateSkillInstallStatusReport(dependencies = {
                 : 'Failed to inspect installed PostPlus skills.',
             installCommand: POSTPLUS_SKILLS_INSTALL_COMMAND,
             installedCount: 0,
+            managedRevision: baseline.revision,
             missingSkills: [...requiredSkills],
             requiredCount: requiredSkills.size,
+            retiredManagedSkills,
             scopes: [],
             source: POSTPLUS_SKILLS_REPO,
             updateCommand: formatPostPlusSkillUpdateCommand(),
@@ -74,7 +107,11 @@ export function formatSkillInstallStatusReport(report) {
         lines.push(`[FAIL] Installed released skills: ${report.installedCount}/${report.requiredCount}`);
     }
     lines.push(`  Source: ${report.source}`);
+    lines.push(`  Managed baseline: ${report.managedRevision ?? 'none'}`);
     lines.push(`  Scope: ${report.scopes.length > 0 ? report.scopes.join(', ') : 'none detected'}`);
+    if (report.retiredManagedSkills.length > 0) {
+        lines.push(`  Retired managed skills: ${formatSkillList(report.retiredManagedSkills, 8)}`, `  Cleanup: ${report.updateCommand}`);
+    }
     if (report.missingSkills.length > 0) {
         lines.push(`  Missing: ${formatSkillList(report.missingSkills, 8)}`, `  Fix: ${report.installCommand}`);
     }
@@ -103,11 +140,12 @@ export function formatPostPlusSkillUpdateCommand() {
 export function formatPostPlusSkillUninstallCommand() {
     return 'postplus uninstall';
 }
+function mergeSkillNames(left, right) {
+    return [...new Set([...left, ...right])].sort((a, b) => a.localeCompare(b));
+}
 async function listInstalledSkills(dependencies) {
-    const [project, global] = await Promise.all([
-        listInstalledSkillsForScope(dependencies, []),
-        listInstalledSkillsForScope(dependencies, ['--global']),
-    ]);
+    const project = await listInstalledSkillsForScope(dependencies, []);
+    const global = await listInstalledSkillsForScope(dependencies, ['--global']);
     const byKey = new Map();
     for (const skill of [...project, ...global]) {
         byKey.set(`${skill.scope}:${skill.name}:${skill.path}`, skill);
@@ -151,5 +189,7 @@ function normalizeInstalledSkillEntry(value) {
 function formatSkillList(skills, limit) {
     const visible = skills.slice(0, limit);
     const rest = skills.length - visible.length;
-    return rest > 0 ? `${visible.join(', ')} (+${rest} more)` : visible.join(', ');
+    return rest > 0
+        ? `${visible.join(', ')} (+${rest} more)`
+        : visible.join(', ');
 }

package/build/status.js

@@ -17,7 +17,8 @@ export async function generateStatusReportWithDependencies(dependencies = {}) {
         generateUpdateStatus(),
     ]);
     return {
-        ok: doctor.ok && auth.ok && skills.ok && updates.ok,
+        schemaVersion: 1,
+        ok: doctor.requiredOk && auth.ok && skills.ok && updates.ok,
         doctor,
         auth,
         skills,
@@ -25,10 +26,15 @@ export async function generateStatusReportWithDependencies(dependencies = {}) {
     };
 }
 export function formatStatusReport(report) {
+    const taskSpecificChecksNeedAttention = report.doctor.requiredOk && !report.doctor.ok;
     return [
         'PostPlus CLI status',
         '',
-        `Overall: ${report.ok ? 'OK' : 'INCOMPLETE'}`,
+        `Overall: ${report.ok
+            ? taskSpecificChecksNeedAttention
+                ? 'OK (task-specific checks need attention)'
+                : 'OK'
+            : 'INCOMPLETE'}`,
         '',
         formatDoctorReport(report.doctor),
         '',

package/build/update-check.js

@@ -1,17 +1,16 @@
-import { createHash } from 'node:crypto';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { getPostPlusConfigDir } from './local-state.js';
-import { POSTPLUS_SKILLS_REPO } from './skill-catalog.js';
+import { getPostPlusConfigDir, readManagedSkillBaseline, } from './local-state.js';
+import { POSTPLUS_SKILLS_REPO, loadPublicSkillCatalog, } from './skill-catalog.js';
 const UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1000;
 const UPDATE_CHECK_CACHE_FILE = 'update-check.json';
 const NPM_PACKAGE_NAME = '@postplus/cli';
 const NPM_LATEST_URL = `https://registry.npmjs.org/${encodeURIComponent(NPM_PACKAGE_NAME)}/latest`;
-const POSTPLUS_SKILLS_MAIN_URL = 'https://api.github.com/repos/PostPlusAI/postplus-skills/commits/main';
 export async function generateUpdateStatusReport(input = {}, dependencies = {
     fetchFn: fetch,
 }) {
     const currentVersion = await readCurrentCliVersion();
+    const managedSkillBaseline = await readManagedSkillBaseline();
     const cache = await readUpdateCheckCache();
     if (cache &&
         !input.force &&
@@ -20,7 +19,7 @@ export async function generateUpdateStatusReport(input = {}, dependencies = {
         return buildUpdateReport({
             cache,
             currentVersion,
-            previousSkillRevision: cache.skills.latestRevision,
+            currentSkillRevision: managedSkillBaseline.revision,
             source: 'cache',
         });
     }
@@ -43,9 +42,7 @@ export async function generateUpdateStatusReport(input = {}, dependencies = {
         return buildUpdateReport({
             cache: nextCache,
             currentVersion,
-            previousSkillRevision: input.resetSkillBaseline
-                ? latestSkillRevision
-                : cache?.skills.latestRevision ?? latestSkillRevision,
+            currentSkillRevision: managedSkillBaseline.revision,
             source: 'remote',
         });
     }
@@ -56,7 +53,7 @@ export async function generateUpdateStatusReport(input = {}, dependencies = {
                 ...buildUpdateReport({
                     cache,
                     currentVersion,
-                    previousSkillRevision: cache.skills.latestRevision,
+                    currentSkillRevision: managedSkillBaseline.revision,
                     source: 'cache',
                 }),
                 warning,
@@ -73,7 +70,7 @@ export async function generateUpdateStatusReport(input = {}, dependencies = {
                 updateCommand: 'npm install -g @postplus/cli',
             },
             skills: {
-                currentRevision: null,
+                currentRevision: managedSkillBaseline.revision,
                 latestRevision: null,
                 updateAvailable: false,
                 updateCommand: 'postplus update',
@@ -82,10 +79,9 @@ export async function generateUpdateStatusReport(input = {}, dependencies = {
         };
     }
 }
-export async function refreshUpdateCheckBaseline() {
+export async function refreshUpdateCheckCache() {
     await generateUpdateStatusReport({
         force: true,
-        resetSkillBaseline: true,
     });
 }
 export function formatUpdateStatusReport(report) {
@@ -116,19 +112,20 @@ function buildUpdateReport(input) {
         cli: {
             currentVersion: input.currentVersion,
             latestVersion: input.cache.cli.latestVersion,
-            updateAvailable: compareVersions(input.cache.cli.latestVersion, input.currentVersion) > 0,
+            updateAvailable: compareVersions(input.cache.cli.latestVersion, input.currentVersion) >
+                0,
             updateCommand: 'npm install -g @postplus/cli',
         },
         skills: {
-            currentRevision: input.previousSkillRevision,
+            currentRevision: input.currentSkillRevision,
             latestRevision: input.cache.skills.latestRevision,
-            updateAvailable: input.cache.skills.latestRevision !== input.previousSkillRevision,
+            updateAvailable: input.cache.skills.latestRevision !== input.currentSkillRevision,
             updateCommand: 'postplus update',
         },
         warning: null,
     };
 }
-async function readCurrentCliVersion() {
+export async function readCurrentCliVersion() {
     const packageJsonPath = new URL('../package.json', import.meta.url);
     const raw = await readFile(packageJsonPath, 'utf8');
     const parsed = JSON.parse(raw);
@@ -155,23 +152,12 @@ async function fetchLatestCliVersion(fetchFn) {
     return payload.version.trim();
 }
 async function fetchLatestSkillRevision(fetchFn) {
-    const response = await fetchFn(POSTPLUS_SKILLS_MAIN_URL, {
-        headers: {
-            accept: 'application/vnd.github+json',
-            'user-agent': `postplus-cli-update-check/${await readCurrentCliVersion()}`,
-        },
-        signal: AbortSignal.timeout(15_000),
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to check latest ${POSTPLUS_SKILLS_REPO} revision (${response.status}).`);
+    try {
+        return (await loadPublicSkillCatalog(fetchFn)).revision;
     }
-    const payload = (await response.json());
-    if (typeof payload.sha === 'string' && payload.sha.trim()) {
-        return payload.sha.trim();
+    catch (error) {
+        throw new Error(`Failed to check latest ${POSTPLUS_SKILLS_REPO} revision: ${error instanceof Error ? error.message : String(error)}`);
     }
-    return createHash('sha256')
-        .update(JSON.stringify(payload))
-        .digest('hex');
 }
 async function readUpdateCheckCache() {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postplus/cli",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "packageManager": "pnpm@10.30.3+sha512.c961d1e0a2d8e354ecaa5166b822516668b7f44cb5bd95122d590dd81922f606f5473b6d23ec4a5be05e7fcd18e8488d47d978bbe981872f1145d06e9a740017",
   "type": "module",
   "description": "PostPlus CLI for PostPlus Cloud auth, status, and diagnostics.",
@@ -15,6 +15,7 @@
     "build/doctor.js",
     "build/hosted-release.js",
     "build/index.js",
+    "build/local-dependencies.js",
     "build/local-state.js",
     "build/skill-catalog.js",
     "build/skill-management.js",