@hongmaple0820/scale-engine 0.38.0 → 0.39.0

package/dist/bootstrap/DependencyBootstrap.js

@@ -1,23 +1,29 @@
-import { existsSync, mkdirSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
-import { execa } from 'execa';
+import { execa, execaSync } from 'execa';
 import { inspectCodeIntelligence, writeCodeIntelligenceConfig } from '../codegraph/CodeIntelligence.js';
 import { externalCommandExists } from '../core/ExternalCommand.js';
 import { inspectMemoryProviders, useMemoryProvider, writeMemoryProvidersConfig } from '../memory/MemoryProviders.js';
 import { wrapShellCommandWithRtk } from '../tools/RtkRuntime.js';
 import { inspectToolCapabilities } from '../tools/ToolCapabilityRegistry.js';
 const UI_SKILL_INSTALLS = {
-    'awesome-design-md': 'npx skills add https://github.com/VoltAgent/awesome-design-md --skill awesome-design-md',
-    'ui-ux-pro-max': 'npx skills add https://github.com/nextlevelbuilder/ui-ux-pro-max-skill --skill ui-ux-pro-max',
+    'awesome-design-md': (ctx) => {
+        const installDir = quotePath(join(ctx.homeDir, '.scale', 'vendor', 'awesome-design-md'));
+        return `npx degit VoltAgent/awesome-design-md ${installDir}`;
+    },
+    'ui-ux-pro-max': 'npx uipro-cli init --ai codex',
     'frontend-design': 'npx skills add anthropics/skills --skill frontend-design',
 };
 const RTK_INSTALL = 'cargo install --git https://github.com/rtk-ai/rtk';
 const CODEGRAPH_INSTALL = 'npm install -g @colbymchenry/codegraph';
-const GRAPHIFY_PIP_INSTALL = 'pip install graphifyy && graphify install';
-const GRAPHIFY_PIP3_INSTALL = 'pip3 install graphifyy && graphify install';
-const GRAPHIFY_PYTHON_INSTALL = 'python -m pip install graphifyy && graphify install';
-const GRAPHIFY_PYTHON3_INSTALL = 'python3 -m pip install graphifyy && graphify install';
+const GRAPHIFY_UV_INSTALL = 'uv tool install graphify && graphify install --platform codex';
+const GRAPHIFY_PIPX_INSTALL = 'pipx install graphify && graphify install --platform codex';
+const GRAPHIFY_PIP_INSTALL = 'pip install graphify && graphify install --platform codex';
+const GRAPHIFY_PIP3_INSTALL = 'pip3 install graphify && graphify install --platform codex';
+const GRAPHIFY_PYTHON_INSTALL = 'python -m pip install graphify && graphify install --platform codex';
+const GRAPHIFY_PYTHON3_INSTALL = 'python3 -m pip install graphify && graphify install --platform codex';
+const GBRAIN_INSTALL = 'bun install -g github:garrytan/gbrain && gbrain init --pglite';
 const GBRAIN_SOURCE = 'https://github.com/garrytan/gbrain';
 const DEPENDENCY_BOOTSTRAP_DEFINITIONS = [
     {
@@ -27,9 +33,10 @@ const DEPENDENCY_BOOTSTRAP_DEFINITIONS = [
         packs: ['ui'],
         source: 'https://github.com/VoltAgent/awesome-design-md',
         detectSkillId: 'awesome-design-md',
+        detectPaths: ctx => [join(ctx.homeDir, '.scale', 'vendor', 'awesome-design-md', 'README.md')],
         prerequisites: ['npx'],
-        manualReason: 'Requires npm/npx and the local skills installer to be available before UI brand skills can be added.',
-        installCommand: ctx => ctx.commandExists('npx') ? UI_SKILL_INSTALLS['awesome-design-md'] : null,
+        manualReason: 'Requires npm/npx to sync the upstream DESIGN.md catalog that drives brand and visual-language decisions.',
+        installCommand: ctx => ctx.commandExists('npx') ? UI_SKILL_INSTALLS['awesome-design-md'](ctx) : null,
     },
     {
         id: 'ui-ux-pro-max',
@@ -39,18 +46,18 @@ const DEPENDENCY_BOOTSTRAP_DEFINITIONS = [
         source: 'https://github.com/nextlevelbuilder/ui-ux-pro-max-skill',
         detectSkillId: 'ui-ux-pro-max',
         prerequisites: ['npx'],
-        manualReason: 'Requires npm/npx and the local skills installer to be available before UI review skills can be added.',
+        manualReason: 'Requires npm/npx so the official uipro-cli installer can configure the UX, state, accessibility, and responsive-review skill.',
         installCommand: ctx => ctx.commandExists('npx') ? UI_SKILL_INSTALLS['ui-ux-pro-max'] : null,
     },
     {
         id: 'frontend-design',
         name: 'Frontend Design',
         kind: 'skill',
-        packs: ['ui'],
+        packs: [],
         source: 'https://github.com/anthropics/skills/tree/main/skills/frontend-design',
         detectSkillId: 'frontend-design',
         prerequisites: ['npx'],
-        manualReason: 'Requires npm/npx and the local skills installer to be available before the implementation companion skill can be added.',
+        manualReason: 'Optional implementation companion only; awesome-design-md and ui-ux-pro-max are the default UI stack.',
         installCommand: ctx => ctx.commandExists('npx') ? UI_SKILL_INSTALLS['frontend-design'] : null,
     },
     {
@@ -63,6 +70,7 @@ const DEPENDENCY_BOOTSTRAP_DEFINITIONS = [
         prerequisites: ['cargo'],
         manualReason: 'RTK currently installs from the official Rust toolchain path and needs Cargo on PATH.',
         installCommand: ctx => ctx.commandExists('cargo') ? RTK_INSTALL : null,
+        healthCheck: checkRtkHealth,
     },
     {
         id: 'gbrain',
@@ -71,9 +79,10 @@ const DEPENDENCY_BOOTSTRAP_DEFINITIONS = [
         packs: ['memory'],
         source: GBRAIN_SOURCE,
         detectCommand: 'gbrain',
-        prerequisites: ['git', 'bun'],
-        manualReason: 'The official standalone GBrain install currently needs git + bun and links the CLI from a local clone.',
+        prerequisites: ['bun'],
+        manualReason: 'The official standalone GBrain install needs Bun and then a configured brain (`gbrain init --pglite`) before cross-session recall is usable.',
         installCommand: ctx => buildGbrainInstallCommand(ctx),
+        healthCheck: checkGbrainHealth,
     },
     {
         id: 'graphify',
@@ -82,9 +91,10 @@ const DEPENDENCY_BOOTSTRAP_DEFINITIONS = [
         packs: ['knowledge'],
         source: 'https://github.com/safishamsi/graphify',
         detectCommand: 'graphify',
-        prerequisites: ['pip|pip3|python|python3'],
-        manualReason: 'Graphify requires Python 3.10+ and a working pip/python path before the CLI can be installed.',
+        prerequisites: ['uv|pipx|pip|pip3|python|python3'],
+        manualReason: 'Graphify requires Python 3.10+ and a supported installer; uv tool install is preferred to avoid polluting project virtualenvs.',
         installCommand: ctx => buildGraphifyInstallCommand(ctx),
+        healthCheck: checkGraphifyHealth,
     },
     {
         id: 'codegraph',
@@ -96,6 +106,7 @@ const DEPENDENCY_BOOTSTRAP_DEFINITIONS = [
         prerequisites: ['npm'],
         manualReason: 'CodeGraph installs through npm and needs Node.js/npm available on PATH.',
         installCommand: ctx => ctx.commandExists('npm') ? CODEGRAPH_INSTALL : null,
+        healthCheck: checkCodeGraphHealth,
     },
 ];
 export async function bootstrapDependencies(options = {}) {
@@ -111,6 +122,7 @@ export async function bootstrapDependencies(options = {}) {
         commandExists: externalCommandExists,
     };
     const reports = definitions.map(definition => inspectDefinition(definition, context));
+    const runtimeChecks = buildRuntimeChecks(reports);
     if (options.apply) {
         for (const item of reports.filter(entry => entry.status === 'ready')) {
             if (!item.installCommand)
@@ -122,7 +134,10 @@ export async function bootstrapDependencies(options = {}) {
             const rechecked = definition ? inspectDefinition(definition, context) : item;
             item.installed = rechecked.installed;
             item.detectedBy = rechecked.detectedBy;
-            item.status = result.ok && rechecked.installed ? 'installed-now' : 'failed';
+            item.health = rechecked.health;
+            item.status = result.ok && rechecked.installed
+                ? rechecked.status === 'installed' ? 'installed-now' : rechecked.status
+                : 'failed';
             if (!result.ok && !item.error)
                 item.error = `Installation command failed: ${item.installCommand}`;
             if (!result.ok)
@@ -133,14 +148,16 @@ export async function bootstrapDependencies(options = {}) {
     const postChecks = options.apply
         ? runDependencyBootstrapPostChecks({ projectDir, scaleDir, packIds, items: reports, homeDir })
         : [];
-    return buildReport(projectDir, scaleDir, packIds, includeIds, Boolean(options.apply), reports, postActions, postChecks);
+    return buildReport(projectDir, scaleDir, packIds, includeIds, Boolean(options.apply), runtimeChecks, reports, postActions, postChecks);
 }
-function buildReport(projectDir, scaleDir, packIds, includeIds, apply, items, postActions, postChecks) {
+function buildReport(projectDir, scaleDir, packIds, includeIds, apply, runtimeChecks, items, postActions, postChecks) {
     const summary = {
         total: items.length,
         installed: items.filter(item => item.status === 'installed').length,
         ready: items.filter(item => item.status === 'ready').length,
         manualReview: items.filter(item => item.status === 'manual-review').length,
+        needsInit: items.filter(item => item.status === 'needs-init').length,
+        versionDrift: items.filter(item => item.status === 'version-drift').length,
         installedNow: items.filter(item => item.status === 'installed-now').length,
         failed: items.filter(item => item.status === 'failed').length,
     };
@@ -154,10 +171,24 @@ function buildReport(projectDir, scaleDir, packIds, includeIds, apply, items, po
     const recommendations = [];
     const postCheckCommands = buildPostCheckCommands(packIds, items);
     const rollbackHints = buildRollbackHints(items);
-    if (!apply && !complete)
+    if (!apply && summary.ready > 0)
         recommendations.push('Re-run with --apply to install all ready dependencies in one pass.');
+    if (runtimeChecks.some(check => check.status === 'missing'))
+        recommendations.push('Install missing runtime dependencies before running --apply.');
+    if (runtimeChecks.some(check => check.status === 'warn'))
+        recommendations.push('Review runtime warnings; some tools may install but fail initialization or post-checks.');
     if (summary.manualReview > 0)
         recommendations.push('Review manual-review items for missing package managers, PATH setup, or platform-specific configuration.');
+    if (summary.needsInit > 0)
+        recommendations.push('Run the listed initialization commands before treating installed CLIs as ready for autonomous use.');
+    if (summary.versionDrift > 0)
+        recommendations.push('Resolve version-drift items before relying on their generated skills, hooks, or artifacts.');
+    if (items.some(item => item.id === 'frontend-design'))
+        recommendations.push('frontend-design is optional; keep it as an explicit companion only when implementation ideation is needed.');
+    if (items.some(item => item.id === 'awesome-design-md'))
+        recommendations.push('Use awesome-design-md as the source of DESIGN.md, brand direction, and visual-language selection.');
+    if (items.some(item => item.id === 'ui-ux-pro-max'))
+        recommendations.push('Use ui-ux-pro-max for UX flow, UI state, accessibility, and responsive acceptance checks.');
     if (items.some(item => item.id === 'gbrain'))
         recommendations.push('After GBrain is installed, validate remote or thin-client health with `scale memory provider status --json`.');
     if (items.some(item => item.id === 'graphify' || item.id === 'codegraph'))
@@ -174,6 +205,7 @@ function buildReport(projectDir, scaleDir, packIds, includeIds, apply, items, po
         packIds,
         includeIds,
         apply,
+        runtimeChecks,
         items,
         summary,
         postActions,
@@ -184,6 +216,247 @@ function buildReport(projectDir, scaleDir, packIds, includeIds, apply, items, po
         recommendations,
     };
 }
+function buildRuntimeChecks(items) {
+    const ids = new Set(items.map(item => item.id));
+    const requirements = new Map();
+    const requireRuntime = (runtimeId, requiredFor) => {
+        const existing = requirements.get(runtimeId) ?? new Set();
+        for (const value of requiredFor)
+            existing.add(value);
+        requirements.set(runtimeId, existing);
+    };
+    const uiIds = ['awesome-design-md', 'ui-ux-pro-max', 'frontend-design'].filter(id => ids.has(id));
+    if (uiIds.length > 0) {
+        requireRuntime('node', uiIds);
+        requireRuntime('npx', uiIds);
+    }
+    if (ids.has('rtk'))
+        requireRuntime('cargo', ['rtk']);
+    if (ids.has('gbrain'))
+        requireRuntime('bun', ['gbrain']);
+    if (ids.has('graphify')) {
+        requireRuntime('python', ['graphify']);
+        requireRuntime('python-installer', ['graphify']);
+    }
+    if (ids.has('codegraph')) {
+        requireRuntime('node', ['codegraph']);
+        requireRuntime('npm', ['codegraph']);
+    }
+    const checks = [];
+    const requiredFor = (runtimeId) => [...(requirements.get(runtimeId) ?? [])];
+    if (requirements.has('node'))
+        checks.push(nodeRuntimeCheck(requiredFor('node')));
+    if (requirements.has('npx'))
+        checks.push(commandRuntimeCheck({
+            id: 'npx',
+            label: 'npx',
+            candidates: [{ command: 'npx', args: ['--version'], display: 'npx' }],
+            requiredFor: requiredFor('npx'),
+            installHint: 'Install Node.js 20+; npm/npx are bundled with the official Node.js installer.',
+        }));
+    if (requirements.has('npm'))
+        checks.push(commandRuntimeCheck({
+            id: 'npm',
+            label: 'npm',
+            candidates: [{ command: 'npm', args: ['--version'], display: 'npm' }],
+            requiredFor: requiredFor('npm'),
+            installHint: 'Install Node.js 20+; npm is bundled with the official Node.js installer.',
+        }));
+    if (requirements.has('cargo'))
+        checks.push(commandRuntimeCheck({
+            id: 'cargo',
+            label: 'Rust/Cargo',
+            candidates: [{ command: 'cargo', args: ['--version'], display: 'cargo' }],
+            requiredFor: requiredFor('cargo'),
+            installHint: 'Install Rust with rustup, then re-open the shell so cargo is on PATH.',
+        }));
+    if (requirements.has('bun'))
+        checks.push(commandRuntimeCheck({
+            id: 'bun',
+            label: 'Bun',
+            candidates: [{ command: 'bun', args: ['--version'], display: 'bun' }],
+            requiredFor: requiredFor('bun'),
+            installHint: 'Install Bun from https://bun.sh and re-open the shell so bun is on PATH.',
+        }));
+    if (requirements.has('python'))
+        checks.push(pythonRuntimeCheck(requiredFor('python')));
+    if (requirements.has('python-installer'))
+        checks.push(pythonInstallerRuntimeCheck(requiredFor('python-installer')));
+    return checks;
+}
+function commandRuntimeCheck(input) {
+    const detected = firstAvailableRuntimeTool(input.candidates);
+    if (!detected) {
+        return {
+            id: input.id,
+            label: input.label,
+            commands: input.candidates.map(candidate => candidate.display),
+            status: 'missing',
+            requiredFor: input.requiredFor,
+            reason: `${input.label} was not detected on PATH.`,
+            installHint: input.installHint,
+        };
+    }
+    return {
+        id: input.id,
+        label: input.label,
+        commands: input.candidates.map(candidate => candidate.display),
+        status: 'ok',
+        requiredFor: input.requiredFor,
+        detectedCommand: detected.display,
+        version: firstLine(detected.output),
+        reason: `${input.label} is available via ${detected.display}.`,
+        installHint: input.installHint,
+    };
+}
+function nodeRuntimeCheck(requiredFor) {
+    const detected = firstAvailableRuntimeTool([{ command: 'node', args: ['--version'], display: 'node' }]);
+    const commands = ['node'];
+    const installHint = 'Install Node.js 20+ from https://nodejs.org.';
+    if (!detected) {
+        return {
+            id: 'node',
+            label: 'Node.js',
+            commands,
+            status: 'missing',
+            requiredFor,
+            reason: 'Node.js was not detected on PATH.',
+            installHint,
+        };
+    }
+    const version = firstLine(detected.output);
+    const parsed = parseSemver(version);
+    if (parsed && parsed.major < 20) {
+        return {
+            id: 'node',
+            label: 'Node.js',
+            commands,
+            status: 'warn',
+            requiredFor,
+            detectedCommand: detected.display,
+            version,
+            reason: `Node.js ${version} is installed, but SCALE setup expects Node.js 20+ for current third-party installers.`,
+            installHint,
+        };
+    }
+    return {
+        id: 'node',
+        label: 'Node.js',
+        commands,
+        status: 'ok',
+        requiredFor,
+        detectedCommand: detected.display,
+        version,
+        reason: `Node.js ${version} is available.`,
+        installHint,
+    };
+}
+function pythonRuntimeCheck(requiredFor) {
+    const candidates = [
+        { command: 'python', args: ['--version'], display: 'python' },
+        { command: 'python3', args: ['--version'], display: 'python3' },
+        { command: 'py', args: ['--version'], display: 'py' },
+    ];
+    const detected = firstAvailableRuntimeTool(candidates);
+    const installHint = 'Install Python 3.10+ and prefer uv or pipx for graphify installation.';
+    if (!detected) {
+        return {
+            id: 'python',
+            label: 'Python',
+            commands: candidates.map(candidate => candidate.display),
+            status: 'missing',
+            requiredFor,
+            reason: 'Python 3.10+ was not detected on PATH.',
+            installHint,
+        };
+    }
+    const version = firstLine(detected.output);
+    const parsed = parseSemver(version);
+    if (!parsed || parsed.major < 3 || (parsed.major === 3 && parsed.minor < 10)) {
+        return {
+            id: 'python',
+            label: 'Python',
+            commands: candidates.map(candidate => candidate.display),
+            status: 'warn',
+            requiredFor,
+            detectedCommand: detected.display,
+            version,
+            reason: `${version} is detected, but Graphify requires Python 3.10+.`,
+            installHint,
+        };
+    }
+    return {
+        id: 'python',
+        label: 'Python',
+        commands: candidates.map(candidate => candidate.display),
+        status: 'ok',
+        requiredFor,
+        detectedCommand: detected.display,
+        version,
+        reason: `${version} is available for Graphify.`,
+        installHint,
+    };
+}
+function pythonInstallerRuntimeCheck(requiredFor) {
+    const candidates = [
+        { command: 'uv', args: ['--version'], display: 'uv' },
+        { command: 'pipx', args: ['--version'], display: 'pipx' },
+        { command: 'pip', args: ['--version'], display: 'pip' },
+        { command: 'pip3', args: ['--version'], display: 'pip3' },
+        { command: 'python', args: ['-m', 'pip', '--version'], display: 'python -m pip' },
+        { command: 'python3', args: ['-m', 'pip', '--version'], display: 'python3 -m pip' },
+    ];
+    const detected = firstAvailableRuntimeTool(candidates);
+    const installHint = 'Install uv or pipx first; pip is supported only as a fallback for graphify.';
+    if (!detected) {
+        return {
+            id: 'python-installer',
+            label: 'Python installer',
+            commands: candidates.map(candidate => candidate.display),
+            status: 'missing',
+            requiredFor,
+            reason: 'No supported Python installer was detected for graphify.',
+            installHint,
+        };
+    }
+    const version = firstLine(detected.output);
+    const preferred = detected.display === 'uv' || detected.display === 'pipx';
+    return {
+        id: 'python-installer',
+        label: 'Python installer',
+        commands: candidates.map(candidate => candidate.display),
+        status: preferred ? 'ok' : 'warn',
+        requiredFor,
+        detectedCommand: detected.display,
+        version,
+        reason: preferred
+            ? `${detected.display} is available for isolated graphify installation.`
+            : `${detected.display} is available, but uv or pipx is preferred to avoid polluting project environments.`,
+        installHint,
+    };
+}
+function firstAvailableRuntimeTool(candidates) {
+    for (const candidate of candidates) {
+        const result = runHealthCommand(candidate.command, candidate.args);
+        if (!result.ok)
+            continue;
+        return {
+            display: candidate.display,
+            output: `${result.stdout}\n${result.stderr}`.trim(),
+        };
+    }
+    return undefined;
+}
+function parseSemver(value) {
+    const match = value.match(/(\d+)\.(\d+)(?:\.(\d+))?/);
+    if (!match)
+        return null;
+    return {
+        major: Number.parseInt(match[1], 10),
+        minor: Number.parseInt(match[2], 10),
+        patch: Number.parseInt(match[3] ?? '0', 10),
+    };
+}
 export function runDependencyBootstrapPostChecks(input, deps = {}) {
     const inspectTools = deps.inspectTools ?? inspectToolCapabilities;
     const inspectMemory = deps.inspectMemory ?? inspectMemoryProviders;
@@ -267,6 +540,7 @@ function inspectDefinition(definition, context) {
         command: requirement,
         present: requirementSatisfied(requirement, context.commandExists),
     }));
+    const health = installed && definition.healthCheck ? definition.healthCheck(context) : undefined;
     const installCommand = installed ? undefined : definition.installCommand(context) ?? undefined;
     const installSupported = Boolean(installCommand);
     return {
@@ -276,15 +550,22 @@ function inspectDefinition(definition, context) {
         packs: definition.packs,
         source: definition.source,
         installed,
-        status: installed ? 'installed' : installSupported ? 'ready' : 'manual-review',
+        status: installed
+            ? health?.bootstrapStatus ?? 'installed'
+            : installSupported ? 'ready' : 'manual-review',
         installCommand,
         installSupported,
         detectedBy,
         prerequisites,
         manualReason: installed ? undefined : definition.manualReason,
+        health,
     };
 }
 function detectDefinition(definition, projectDir, homeDir) {
+    const context = { projectDir, homeDir, commandExists: externalCommandExists };
+    const detectedPath = definition.detectPaths?.(context).find(candidate => existsSync(candidate));
+    if (detectedPath)
+        return detectedPath;
     if (definition.detectSkillId) {
         const path = skillCandidatePaths(projectDir, homeDir, definition.detectSkillId).find(candidate => existsSync(candidate));
         return path ?? 'missing';
@@ -307,6 +588,10 @@ function requirementSatisfied(requirement, commandExists) {
     return requirement.split('|').some(command => commandExists(command));
 }
 function buildGraphifyInstallCommand(context) {
+    if (context.commandExists('uv'))
+        return GRAPHIFY_UV_INSTALL;
+    if (context.commandExists('pipx'))
+        return GRAPHIFY_PIPX_INSTALL;
     if (context.commandExists('pip'))
         return GRAPHIFY_PIP_INSTALL;
     if (context.commandExists('pip3'))
@@ -318,15 +603,114 @@ function buildGraphifyInstallCommand(context) {
     return null;
 }
 function buildGbrainInstallCommand(context) {
-    if (!context.commandExists('git') || !context.commandExists('bun'))
+    if (!context.commandExists('bun'))
         return null;
-    const vendorRoot = join(context.homeDir, '.scale', 'vendor');
-    const installDir = join(vendorRoot, 'gbrain');
-    mkdirSync(vendorRoot, { recursive: true });
-    const changeDir = process.platform === 'win32' ? `cd /d "${installDir}"` : `cd "${installDir}"`;
-    if (existsSync(installDir))
-        return `${changeDir} && git pull --ff-only && bun install && bun link`;
-    return `git clone ${GBRAIN_SOURCE}.git "${installDir}" && ${changeDir} && bun install && bun link`;
+    return GBRAIN_INSTALL;
+}
+function checkRtkHealth() {
+    const gain = runHealthCommand('rtk', ['gain']);
+    if (!gain.ok) {
+        return {
+            status: 'warn',
+            bootstrapStatus: 'needs-init',
+            reason: 'rtk CLI is installed but `rtk gain` did not run successfully; token-savings evidence is not available yet.',
+            nextCommands: ['rtk init -g --codex', 'rtk gain'],
+        };
+    }
+    const output = `${gain.stdout}\n${gain.stderr}`;
+    if (/no hook installed/i.test(output)) {
+        return {
+            status: 'warn',
+            bootstrapStatus: 'needs-init',
+            reason: 'rtk CLI is installed, but the shell hook is not installed so command-output compression is not automatic yet.',
+            nextCommands: ['rtk init -g --codex', 'rtk gain'],
+        };
+    }
+    return { status: 'ok', reason: 'rtk CLI and gain evidence are available.' };
+}
+function checkGbrainHealth() {
+    const doctor = runHealthCommand('gbrain', ['doctor', '--json'], 10_000);
+    if (doctor.ok)
+        return { status: 'ok', reason: 'gbrain doctor passed; provider can be used for default memory routing.' };
+    const output = `${doctor.stdout}\n${doctor.stderr}`;
+    return {
+        status: 'warn',
+        bootstrapStatus: 'needs-init',
+        reason: /no brain configured/i.test(output)
+            ? 'gbrain CLI is installed but no brain is configured yet; cross-session recall will fail until initialized.'
+            : `gbrain CLI is installed but doctor failed: ${firstLine(output)}`,
+        nextCommands: ['gbrain init --pglite', 'gbrain doctor --json', 'scale memory provider status --json'],
+    };
+}
+function checkGraphifyHealth() {
+    const version = runHealthCommand('graphify', ['--version']);
+    const hook = runHealthCommand('graphify', ['hook', 'status'], 10_000);
+    const output = `${version.stdout}\n${version.stderr}\n${hook.stdout}\n${hook.stderr}`;
+    if (/skill.*version|package.*version|drift|outdated/i.test(output)) {
+        return {
+            status: 'warn',
+            bootstrapStatus: 'version-drift',
+            reason: 'graphify CLI is installed but its generated skill/hook assets appear out of sync with the package.',
+            nextCommands: ['graphify install --platform codex', 'graphify hook status', 'scale codegraph status --json'],
+        };
+    }
+    if (!hook.ok || /not installed|missing/i.test(output)) {
+        return {
+            status: 'warn',
+            bootstrapStatus: 'needs-init',
+            reason: 'graphify CLI is installed but Codex hooks are not fully configured.',
+            nextCommands: ['graphify install --platform codex', 'graphify hook status'],
+        };
+    }
+    return { status: 'ok', reason: 'graphify CLI and hook status are available.' };
+}
+function checkCodeGraphHealth(context) {
+    const indexPath = join(context.projectDir, '.codegraph');
+    if (!existsSync(indexPath)) {
+        return {
+            status: 'warn',
+            bootstrapStatus: 'needs-init',
+            reason: 'codegraph CLI is installed but this project has no .codegraph index yet.',
+            nextCommands: ['codegraph init -i', 'scale codegraph status --json'],
+        };
+    }
+    const status = runHealthCommand('codegraph', ['status', context.projectDir], 10_000);
+    if (!status.ok) {
+        return {
+            status: 'warn',
+            bootstrapStatus: 'needs-init',
+            reason: `codegraph index exists but status check failed: ${firstLine(`${status.stdout}\n${status.stderr}`)}`,
+            nextCommands: ['codegraph init -i', 'codegraph status .'],
+        };
+    }
+    return { status: 'ok', reason: 'codegraph CLI and project index are available.' };
+}
+function runHealthCommand(command, args, timeout = 5_000) {
+    try {
+        const result = execaSync(command, args, {
+            reject: false,
+            timeout,
+        });
+        return {
+            ok: (result.exitCode ?? 1) === 0,
+            stdout: result.stdout ?? '',
+            stderr: result.stderr ?? '',
+        };
+    }
+    catch (error) {
+        const err = error;
+        return {
+            ok: false,
+            stdout: String(err.stdout ?? ''),
+            stderr: String(err.stderr ?? err.message ?? ''),
+        };
+    }
+}
+function firstLine(value) {
+    return value.split(/\r?\n/).map(line => line.trim()).find(Boolean) ?? 'unknown error';
+}
+function quotePath(path) {
+    return `"${path.replace(/"/g, '\\"')}"`;
 }
 async function runInstallCommand(shellCommand) {
     const wrapped = wrapShellCommandWithRtk(shellCommand);
@@ -371,7 +755,11 @@ function buildPostCheckCommands(packIds, items) {
     const selectedPacks = new Set(packIds.includes('full') ? ['ui', 'memory', 'knowledge', 'external-cli'] : packIds);
     const ids = new Set(items.map(item => item.id));
     if (selectedPacks.has('ui')) {
-        commands.add('scale tool doctor --tools awesome-design-md,ui-ux-pro-max,frontend-design --json');
+        const uiToolIds = items
+            .filter(item => item.kind === 'skill' && item.packs.includes('ui'))
+            .map(item => item.id);
+        if (uiToolIds.length > 0)
+            commands.add(`scale tool doctor --tools ${uiToolIds.join(',')} --json`);
         commands.add('scale skill doctor --json');
     }
     if (selectedPacks.has('memory') || ids.has('gbrain')) {
@@ -398,7 +786,7 @@ function buildRollbackHints(items) {
                 hints.add('CodeGraph rollback: npm uninstall -g @colbymchenry/codegraph');
                 break;
             case 'graphify':
-                hints.add('Graphify rollback: pip uninstall graphifyy  # or pip3/python -m pip uninstall graphifyy');
+                hints.add('Graphify rollback: pip uninstall graphify  # or pip3/python -m pip uninstall graphify');
                 break;
             case 'gbrain':
                 hints.add('GBrain rollback: bun unlink gbrain, then remove ~/.scale/vendor/gbrain if you want a full local cleanup');