@indy2kro/agentenv 0.2.2 → 0.3.0

package/dist/commands/status.js

@@ -3,11 +3,13 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { isAgentInstalled, resolveBinary } from '../adapters/detect.js';
 import { BINARY_MAP, TOOL_DESCRIPTIONS, TOOL_KEYS, TOOL_TIERS, getEnabledAgents, loadConfig, resolveIntegrationScope, validateConfig, } from '../config/schema.js';
-import { findConfigPath, resolveScopeDir } from '../config/scopes.js';
+import { findConfigPath, resolveScopeDir, userConfigDir } from '../config/scopes.js';
 import { checkAgentShellConfiguration, detectShell } from '../shell/detector.js';
 import { SuperpowersAdapter, ghAuthLine } from '../integrations/index.js';
 import { resolveGhAuthProbe } from '../toolchain/gh.js';
+import { MISE_TOOL_NAMES, PINNED_TOOL_VERSIONS, getInstalledToolState, getMiseVersion, } from '../toolchain/mise.js';
 import { colorizeLine, theme } from '../ui/theme.js';
+import { renderLogo, resolveResultLine, setQuietEnabled } from '../ui/output.js';
 const AGENT_CONFIG_FILES = {
     claude_code: {
         label: 'Claude Code',
@@ -30,10 +32,32 @@ const AGENT_CONFIG_FILES = {
     vibe: { label: 'Mistral Vibe', check: (baseDir) => path.join(baseDir, 'RTK.md') },
 };
 export { AGENT_CONFIG_FILES };
+export function computeStatusExitCode(report) {
+    const drifted = report.config === null ||
+        report.validation.errors.length > 0 ||
+        report.tools.some((tool) => tool.drift) ||
+        report.agents.some((agent) => agent.drift) ||
+        report.generated.some((entry) => !entry.exists || !entry.managed) ||
+        report.integrations.some((integration) => integration.drift) ||
+        report.customTools.some((tool) => tool.drift);
+    return drifted ? 1 : 0;
+}
+const defaultSuperpowersStatus = async (baseDir, config) => {
+    const adapter = new SuperpowersAdapter();
+    return adapter.status(baseDir, config);
+};
 function homeDir() {
     return process.env.HOME || process.env.USERPROFILE || '';
 }
-function containsManagedMarker(file, config) {
+function norm(p) {
+    return path.resolve(p).replace(/\\/g, '/').toLowerCase();
+}
+function scopeFromConfigPath(configPath) {
+    return norm(configPath) === norm(path.join(userConfigDir(), 'agentenv.toml'))
+        ? 'user'
+        : 'project';
+}
+function hasManagedMarker(file, config) {
     try {
         const content = fs.readFileSync(file, 'utf-8');
         const marker = config.generate?.marker_start ?? '<!-- agentenv-managed-start -->';
@@ -43,172 +67,453 @@ function containsManagedMarker(file, config) {
         return false;
     }
 }
-function customToolStatus(tool) {
-    if (tool.already_installed) {
-        const candidate = pathForPlatform(tool);
-        if (candidate && fs.existsSync(candidate))
-            return `present (${candidate})`;
-        return 'MISSING on disk';
-    }
-    return `mise source: ${tool.mise_source}${tool.version ? ` (${tool.version})` : ''}`;
-}
-function pathForPlatform(tool) {
+function customToolPath(tool) {
     if (process.platform === 'win32')
         return tool.path_windows;
     if (process.platform === 'darwin')
         return tool.path_macos;
     return tool.path_linux;
 }
-export const statusCommand = new Command()
-    .name('status')
-    .description('Show current configuration and environment status')
-    .action(async () => {
-    console.log(theme.heading('\n=== agentenv status ===\n'));
-    const configPath = findConfigPath();
+function customToolStatus(tool, exists) {
+    if (tool.already_installed) {
+        const candidate = customToolPath(tool);
+        const pathExists = candidate !== undefined && exists(candidate);
+        return {
+            status: candidate && pathExists ? `present (${candidate})` : 'MISSING on disk',
+            drift: !pathExists,
+        };
+    }
+    return {
+        status: `mise source: ${tool.mise_source}${tool.version ? ` (${tool.version})` : ''}`,
+        drift: false,
+    };
+}
+function tier0Report(shell, enabledAgents, deps) {
+    const isWindows = shell.isWindows;
+    const shellHome = homeDir();
+    const agentChecks = isWindows === true
+        ? enabledAgents.map((agent) => ({
+            agent,
+            label: AGENT_CONFIG_FILES[agent]?.label ?? agent,
+            needsFix: (deps.checkAgentShellConfiguration ?? checkAgentShellConfiguration)(agent, shellHome).needsFix,
+        }))
+        : [];
+    return {
+        isWindows,
+        currentShell: shell.currentShell,
+        gitBashPath: shell.gitBashPath ?? null,
+        posixCompatible: shell.isPosixCompatible,
+        missingUtilities: shell.missingUtilities,
+        agentChecks,
+        needsFix: isWindows && (!shell.gitBashPath || agentChecks.some((check) => check.needsFix)),
+    };
+}
+/** Gather the full status report (structured, no printing). */
+export async function gatherStatus(deps = {}) {
+    const getMiseVersionFn = deps.getMiseVersion ?? getMiseVersion;
+    const configPath = (deps.findConfigPath ?? findConfigPath)();
     if (!configPath) {
-        console.log('No agentenv.toml found (project or user scope).');
-        console.log('  Run `agentenv setup` or `agentenv configure` to create one.\n');
-        process.exitCode = 1;
-        return;
+        const report = {
+            command: 'status',
+            config: null,
+            scope: null,
+            baseDir: null,
+            exitCode: 0,
+            validation: { errors: [], warnings: [] },
+            agents: [],
+            tools: [],
+            customTools: [],
+            generated: [],
+            integrations: [],
+            rtkEnabled: false,
+            tier0: null,
+            ghAuth: null,
+            miseVersion: getMiseVersionFn(),
+            integrationDetails: [],
+        };
+        return { ...report, exitCode: computeStatusExitCode(report) };
     }
     let config;
     try {
-        config = loadConfig();
+        config = (deps.loadConfig ?? loadConfig)(configPath);
     }
     catch (error) {
-        console.error(theme.fail(error instanceof Error ? error.message : String(error)));
-        process.exitCode = 1;
-        return;
-    }
-    const baseDir = resolveScopeDir(config.scope);
-    console.log(`Config: ${configPath}`);
-    console.log(`Scope: ${config.scope ?? 'project'}`);
-    console.log(`Base directory: ${baseDir}`);
-    const report = validateConfig(config);
-    const validationSummary = `Validation: ${report.errors.length === 0 ? 'valid' : `${report.errors.length} error(s)`}${report.warnings.length > 0 ? `, ${report.warnings.length} warning(s)` : ''}`;
-    console.log(report.errors.length === 0 ? theme.ok(validationSummary) : theme.fail(validationSummary));
-    for (const warning of report.warnings)
-        console.log(theme.warn(`  warning: ${warning}`));
-    console.log(`RTK command rewriting: ${config.rtk?.enabled ? 'enabled' : 'disabled'}`);
+        const scope = scopeFromConfigPath(configPath);
+        const report = {
+            command: 'status',
+            config: configPath,
+            scope,
+            baseDir: (deps.resolveScopeDir ?? resolveScopeDir)(scope),
+            exitCode: 0,
+            validation: {
+                errors: [error instanceof Error ? error.message : String(error)],
+                warnings: [],
+            },
+            agents: [],
+            tools: [],
+            customTools: [],
+            generated: [],
+            integrations: [],
+            rtkEnabled: false,
+            tier0: null,
+            ghAuth: null,
+            miseVersion: getMiseVersionFn(),
+            integrationDetails: [],
+        };
+        return { ...report, exitCode: computeStatusExitCode(report) };
+    }
+    const resolveDir = deps.resolveScopeDir ?? resolveScopeDir;
+    const baseDir = resolveDir(config.scope);
+    const validation = (deps.validateConfig ?? validateConfig)(config);
+    const shell = (deps.detectShell ?? detectShell)();
+    const enabledAgents = (deps.getEnabledAgents ?? getEnabledAgents)(config);
+    const exists = deps.fileExists ?? fs.existsSync;
+    const rtkEnabled = config.rtk?.enabled === true;
+    const agents = enabledAgents.map((agent) => {
+        const meta = AGENT_CONFIG_FILES[agent];
+        const installed = (deps.isAgentInstalled ?? isAgentInstalled)(agent);
+        const configured = exists(meta.check(baseDir));
+        return {
+            key: agent,
+            label: meta.label,
+            installed,
+            configured,
+            drift: installed && !configured,
+        };
+    });
+    const enabledTools = TOOL_KEYS.filter((key) => config.tools?.[key] === true);
+    let ghAuth = null;
+    const installedState = (deps.getInstalledToolState ?? getInstalledToolState)();
+    const hasVersionData = Object.keys(installedState).length > 0;
+    const tools = enabledTools.map((key) => {
+        const binary = BINARY_MAP[key];
+        const found = (deps.resolveBinary ?? resolveBinary)(binary) !== null;
+        if (key === 'gh' && found) {
+            ghAuth = ghAuthLine((deps.resolveGhAuthProbe ?? resolveGhAuthProbe)()().status);
+        }
+        const miseName = MISE_TOOL_NAMES[key] || key;
+        const state = installedState[miseName];
+        const pinned = config.tool_versions?.[key] ?? PINNED_TOOL_VERSIONS[miseName] ?? null;
+        const installedVersions = state?.versions ?? [];
+        const installed = hasVersionData && installedVersions.length > 0
+            ? installedVersions[installedVersions.length - 1]
+            : null;
+        const versionDrift = pinned !== null &&
+            installed !== null &&
+            installedVersions.length > 0 &&
+            !installedVersions.includes(pinned);
+        return {
+            key,
+            binary,
+            tier: TOOL_TIERS[key] ?? 0,
+            found,
+            drift: !found || versionDrift,
+            pinned,
+            installed,
+        };
+    });
+    const customTools = (config.custom_tools ?? []).map((tool) => {
+        const { status, drift } = customToolStatus(tool, exists);
+        return { name: tool.name, status, drift };
+    });
+    const generatedEntries = [
+        ['mise.toml', path.join(baseDir, 'mise.toml'), false],
+        ['AGENTS.md', path.join(baseDir, 'AGENTS.md'), true],
+        ['CLAUDE.md', path.join(baseDir, 'CLAUDE.md'), true],
+    ];
+    const generated = generatedEntries.map(([label, file, markerCheck]) => {
+        const generatedExists = exists(file);
+        const managed = generatedExists &&
+            (markerCheck ? (deps.hasManagedMarker ?? hasManagedMarker)(file, config) : true);
+        return { label, exists: generatedExists, managed };
+    });
+    const integrations = [];
+    const integrationDetails = [];
+    const integrationKey = 'superpowers';
+    const superpowersConfig = config.integrations?.superpowers;
+    if (superpowersConfig?.enabled === true) {
+        // Resolve against the top-level scope before calling the adapter — the
+        // adapter only ever sees an IntegrationConfig, not the full
+        // AgentenvConfig, so it can't fall back to the top-level scope itself
+        // (see the matching resolution in apply.ts).
+        const scope = resolveIntegrationScope(config, superpowersConfig);
+        const result = await (deps.superpowersStatus ?? defaultSuperpowersStatus)(resolveDir(scope), {
+            ...superpowersConfig,
+            scope,
+        });
+        integrations.push({
+            key: integrationKey,
+            enabled: true,
+            source: result.source ?? null,
+            ref: result.ref ?? null,
+            scope: result.scope,
+            agents: superpowersConfig.agents ?? [],
+            states: result.agents.map(({ agent, state, detail }) => ({
+                agent,
+                state,
+                detail: detail ?? null,
+            })),
+            drift: result.agents.some((entry) => entry.state === 'missing' || entry.state === 'drifted'),
+        });
+        integrationDetails.push({
+            key: integrationKey,
+            hooksAllowed: superpowersConfig.allow_hooks ?? false,
+            externalRequestsAllowed: superpowersConfig.allow_external_requests ?? false,
+            warnings: result.warnings,
+        });
+    }
+    else {
+        integrations.push({
+            key: integrationKey,
+            enabled: false,
+            source: null,
+            ref: null,
+            scope: null,
+            agents: [],
+            states: [],
+            drift: false,
+        });
+        integrationDetails.push({
+            key: integrationKey,
+            hooksAllowed: null,
+            externalRequestsAllowed: null,
+            warnings: [],
+        });
+    }
+    const report = {
+        command: 'status',
+        config: configPath,
+        scope: config.scope ?? 'project',
+        baseDir,
+        exitCode: 0,
+        validation,
+        agents,
+        tools,
+        customTools,
+        generated,
+        integrations,
+        rtkEnabled,
+        tier0: tier0Report(shell, enabledAgents, deps),
+        ghAuth,
+        miseVersion: getMiseVersionFn(),
+        integrationDetails,
+    };
+    return { ...report, exitCode: computeStatusExitCode(report) };
+}
+function statusSummary(report) {
+    if (report.config === null) {
+        return {
+            severity: 'fail',
+            headline: 'No configuration found',
+            summary: 'run `agentenv setup` or `agentenv apply` to get started',
+        };
+    }
+    const issues = report.validation.errors.length +
+        report.tools.filter((tool) => tool.drift).length +
+        report.agents.filter((agent) => agent.drift).length +
+        report.customTools.filter((tool) => tool.drift).length +
+        report.generated.filter((entry) => !entry.exists || !entry.managed).length +
+        report.integrations.filter((integration) => integration.drift).length;
+    if (issues === 0) {
+        return { severity: 'ok', headline: 'Environment is clean' };
+    }
+    return {
+        severity: 'fail',
+        headline: `Status: ${issues} issue${issues === 1 ? '' : 's'} found`,
+        summary: 'run `agentenv apply` to fix, or `agentenv update` for new versions',
+    };
+}
+export function statusToJson(report) {
+    return {
+        command: report.command,
+        config: report.config,
+        scope: report.scope,
+        baseDir: report.baseDir,
+        exitCode: report.exitCode,
+        validation: report.validation,
+        agents: report.agents,
+        tools: report.tools,
+        customTools: report.customTools,
+        generated: report.generated,
+        integrations: report.integrations,
+    };
+}
+function displayName(key) {
+    return key.charAt(0).toUpperCase() + key.slice(1);
+}
+/** Collapsed one-line-per-area view for `status --short`. */
+export function renderStatusShort(report) {
+    const chunks = [];
+    chunks.push(`Config: ${report.config ?? '(none)'}`);
+    if (report.config !== null) {
+        chunks.push(`Scope: ${report.scope ?? 'project'}`);
+        chunks.push(`Base directory: ${report.baseDir}`);
+    }
+    const toolDrift = report.tools.filter((tool) => tool.drift).length;
+    chunks.push(`Tools: ${report.tools.length} configured${toolDrift > 0 ? `, ${toolDrift} drifted` : ''}`);
+    const agentDrift = report.agents.filter((agent) => agent.drift).length;
+    chunks.push(`Agents: ${report.agents.length} enabled${agentDrift > 0 ? `, ${agentDrift} drifted` : ''}`);
+    if (report.customTools.length > 0) {
+        const customDrift = report.customTools.filter((tool) => tool.drift).length;
+        chunks.push(`Custom tools: ${report.customTools.length}${customDrift > 0 ? `, ${customDrift} drifted` : ''}`);
+    }
+    const generatedMissing = report.generated.filter((entry) => !entry.exists || !entry.managed).length;
+    chunks.push(`Generated files: ${report.generated.length}${generatedMissing > 0 ? `, ${generatedMissing} missing/unmanaged` : ''}`);
+    if (report.integrations.length > 0) {
+        const integrationDrift = report.integrations.filter((integration) => integration.drift).length;
+        chunks.push(`Integrations: ${report.integrations.length}${integrationDrift > 0 ? `, ${integrationDrift} drifted` : ''}`);
+    }
+    if (report.validation.errors.length > 0) {
+        chunks.push(`Config errors: ${report.validation.errors.length}`);
+    }
+    if (report.validation.warnings.length > 0) {
+        chunks.push(`Warnings: ${report.validation.warnings.length}`);
+    }
+    for (const warning of report.validation.warnings)
+        chunks.push(theme.warn(`  warning: ${warning}`));
+    return `${chunks.join('\n')}\n`;
+}
+/** Render the human report body (banners are emitted by the command). */
+export function renderStatus(report) {
+    if (report.config === null) {
+        return [
+            'No agentenv.toml found (project or user scope).',
+            '  Run `agentenv setup` (alias: `configure`) to create one.',
+            '',
+        ].join('\n');
+    }
+    const chunks = [];
+    chunks.push(`Config: ${report.config}`);
+    chunks.push(`Scope: ${report.scope ?? 'project'}`);
+    chunks.push(`Base directory: ${report.baseDir}`);
+    chunks.push(`Mise: ${report.miseVersion}`);
+    const validationSummary = `Validation: ${report.validation.errors.length === 0 ? 'valid' : `${report.validation.errors.length} error(s)`}${report.validation.warnings.length > 0 ? `, ${report.validation.warnings.length} warning(s)` : ''}`;
+    chunks.push(report.validation.errors.length === 0
+        ? theme.ok(validationSummary)
+        : theme.fail(validationSummary));
+    for (const warning of report.validation.warnings)
+        chunks.push(theme.warn(`  warning: ${warning}`));
+    chunks.push(`RTK command rewriting: ${report.rtkEnabled ? 'enabled' : 'disabled'}`);
     // Tier 0 shell status
-    const shell = detectShell();
-    console.log(theme.heading('\nTier 0 (shell):'));
-    if (shell.isWindows) {
-        // shell.isPosixCompatible reflects THIS interactive shell (PowerShell,
-        // almost always not bash) — that's expected and isn't what `apply`
-        // fixes. What apply actually manages is each enabled agent's own
-        // config pointing at Git Bash, so that's what decides whether a fix
-        // is actually needed.
-        console.log(`  Current shell: ${shell.currentShell}`);
-        if (shell.gitBashPath)
-            console.log(`  Git Bash: ${shell.gitBashPath}`);
-        else
-            console.log('  Git Bash: NOT FOUND');
-        const shellHome = process.env.HOME || process.env.USERPROFILE || '';
-        const agentShellChecks = getEnabledAgents(config).map((agent) => ({
-            agent,
-            check: checkAgentShellConfiguration(agent, shellHome),
-        }));
-        if (agentShellChecks.length > 0) {
-            console.log('  Agent shell overrides:');
-            for (const { agent, check } of agentShellChecks) {
-                const label = AGENT_CONFIG_FILES[agent]?.label ?? agent;
-                console.log(colorizeLine(`    ${check.needsFix ? '✗' : '✓'} ${label}`));
+    if (report.tier0) {
+        chunks.push(theme.heading('\nTier 0 (shell):'));
+        const tier0 = report.tier0;
+        if (tier0.isWindows) {
+            chunks.push(`  Current shell: ${tier0.currentShell}`);
+            if (tier0.gitBashPath)
+                chunks.push(`  Git Bash: ${tier0.gitBashPath}`);
+            else
+                chunks.push('  Git Bash: NOT FOUND');
+            if (tier0.agentChecks.length > 0) {
+                chunks.push('  Agent shell overrides:');
+                for (const check of tier0.agentChecks) {
+                    chunks.push(colorizeLine(`    ${check.needsFix ? '✗' : '✓'} ${check.label}`));
+                }
+            }
+            if (tier0.needsFix) {
+                chunks.push(theme.warn('  Fix: run `agentenv apply` (Tier 0 shell fix)'));
             }
         }
-        if (!shell.gitBashPath || agentShellChecks.some(({ check }) => check.needsFix)) {
-            console.log(theme.warn('  Fix: run `agentenv apply` (Tier 0 shell fix)'));
+        else {
+            chunks.push(`  ${tier0.posixCompatible ? 'POSIX-compatible' : 'non-POSIX'} (not Windows; Tier 0 N/A)`);
+            if (tier0.missingUtilities.length > 0) {
+                chunks.push(`  Missing utilities: ${tier0.missingUtilities.join(', ')}`);
+            }
         }
     }
-    else {
-        console.log(`  ${shell.isPosixCompatible ? 'POSIX-compatible' : 'non-POSIX'} (not Windows; Tier 0 N/A)`);
-        const missing = shell.missingUtilities;
-        if (missing.length > 0)
-            console.log(`  Missing utilities: ${missing.join(', ')}`);
-    }
     // Agents
-    const enabledAgents = getEnabledAgents(config);
-    console.log(theme.heading('\nAgents:'));
-    if (enabledAgents.length === 0) {
-        console.log('  (none enabled)');
+    chunks.push(theme.heading('\nAgents:'));
+    if (report.agents.length === 0) {
+        chunks.push('  (none enabled)');
     }
-    for (const agent of enabledAgents) {
-        const meta = AGENT_CONFIG_FILES[agent];
-        const installed = isAgentInstalled(agent);
-        const configured = fs.existsSync(meta.check(baseDir));
-        const drift = installed && !configured;
-        const line = `  ${meta.label.padEnd(16)} installed: ${installed ? 'yes' : 'no'}   ` +
-            `configured: ${configured ? 'yes' : 'no'}${drift ? '   <- drift: installed but not configured' : ''}`;
-        console.log(drift ? theme.warn(line) : line);
+    for (const agent of report.agents) {
+        const line = `  ${agent.label.padEnd(16)} installed: ${agent.installed ? 'yes' : 'no'}   ` +
+            `configured: ${agent.configured ? 'yes' : 'no'}${agent.drift ? '   <- drift: installed but not configured' : ''}`;
+        chunks.push(agent.drift ? theme.warn(line) : line);
     }
     // Tools
-    const enabledTools = TOOL_KEYS.filter((key) => config.tools?.[key] === true);
-    console.log(theme.heading('\nTools:'));
-    for (const key of enabledTools) {
-        const binary = BINARY_MAP[key];
-        const found = resolveBinary(binary) !== null;
-        const tier = TOOL_TIERS[key] ?? '?';
-        const desc = TOOL_DESCRIPTIONS[key] ?? '';
-        console.log(colorizeLine(`  ${found ? '✓' : '✗'} ${binary.padEnd(12)} ${key} (Tier ${tier})${found ? '' : '   <- drift: enabled in config but not on PATH'} — ${desc}`));
-        if (key === 'gh' && found) {
-            console.log(colorizeLine(`      ${ghAuthLine(resolveGhAuthProbe()().status)}`));
+    chunks.push(theme.heading('\nTools:'));
+    for (const tool of report.tools) {
+        const desc = TOOL_DESCRIPTIONS[tool.key] ?? '';
+        const versionTail = !tool.found
+            ? ''
+            : tool.pinned !== null
+                ? tool.installed !== null && tool.installed !== tool.pinned
+                    ? `   <- drift: version ${tool.pinned} configured, ${tool.installed} installed`
+                    : ` (${tool.pinned} installed)`
+                : tool.installed !== null
+                    ? ` (${tool.installed})`
+                    : '';
+        chunks.push(colorizeLine(`  ${tool.found ? '✓' : '✗'} ${tool.binary.padEnd(12)} ${tool.key} (Tier ${tool.tier})${tool.found ? `${versionTail}` : '   <- drift: enabled in config but not on PATH'} — ${desc}`));
+        if (tool.key === 'gh' && report.ghAuth) {
+            chunks.push(colorizeLine(`      ${report.ghAuth}`));
         }
     }
-    if (enabledTools.length === 0)
-        console.log('  (none enabled)');
+    if (report.tools.length === 0)
+        chunks.push('  (none enabled)');
     // Custom tools
-    const customTools = config.custom_tools ?? [];
-    console.log(theme.heading('\nCustom tools:'));
-    if (customTools.length === 0) {
-        console.log('  (none)');
+    chunks.push(theme.heading('\nCustom tools:'));
+    if (report.customTools.length === 0) {
+        chunks.push('  (none)');
     }
-    for (const tool of customTools) {
-        console.log(`  ${tool.name}: ${customToolStatus(tool)}`);
+    for (const tool of report.customTools) {
+        chunks.push(`  ${tool.name}: ${tool.status}`);
     }
     // Generated files
-    console.log(theme.heading('\nGenerated files:'));
-    const generated = [
-        ['mise.toml', path.join(baseDir, 'mise.toml'), false],
-        ['AGENTS.md', path.join(baseDir, 'AGENTS.md'), true],
-        ['CLAUDE.md', path.join(baseDir, 'CLAUDE.md'), true],
-    ];
-    for (const [label, file, markerCheck] of generated) {
-        const exists = fs.existsSync(file);
-        if (!exists) {
-            console.log(theme.fail(`  ✗ ${label} (missing)`));
+    chunks.push(theme.heading('\nGenerated files:'));
+    for (const entry of report.generated) {
+        if (!entry.exists) {
+            chunks.push(theme.fail(`  ✗ ${entry.label} (missing)`));
             continue;
         }
-        const managed = markerCheck ? containsManagedMarker(file, config) : true;
-        console.log(colorizeLine(`  ✓ ${label}${managed ? '' : ' (managed marker block missing)'}`));
+        chunks.push(colorizeLine(`  ✓ ${entry.label}${entry.managed ? '' : ' (managed marker block missing)'}`));
     }
     // Integrations
-    console.log(theme.heading('\nIntegrations:'));
-    const superpowersConfig = config.integrations?.superpowers;
-    console.log('  Superpowers');
-    if (!superpowersConfig || superpowersConfig.enabled !== true) {
-        console.log('    enabled: no');
-    }
-    else {
-        // Resolve against the top-level scope before calling the adapter — the
-        // adapter only ever sees an IntegrationConfig, not the full
-        // AgentenvConfig, so it can't fall back to the top-level scope itself
-        // (see the matching resolution in apply.ts).
-        const scope = resolveIntegrationScope(config, superpowersConfig);
-        const adapter = new SuperpowersAdapter();
-        const result = await adapter.status(resolveScopeDir(scope), { ...superpowersConfig, scope });
-        console.log('    enabled: yes');
-        console.log(`    source: ${result.source ?? '(unset)'}`);
-        console.log(`    ref: ${result.ref ?? '(unset)'}`);
-        console.log(`    scope: ${result.scope}`);
-        for (const agentState of result.agents) {
+    chunks.push(theme.heading('\nIntegrations:'));
+    for (const integration of report.integrations) {
+        chunks.push(`  ${displayName(integration.key)}`);
+        if (!integration.enabled) {
+            chunks.push('    enabled: no');
+            continue;
+        }
+        chunks.push('    enabled: yes');
+        chunks.push(`    source: ${integration.source ?? '(unset)'}`);
+        chunks.push(`    ref: ${integration.ref ?? '(unset)'}`);
+        chunks.push(`    scope: ${integration.scope}`);
+        for (const agentState of integration.states) {
             const label = AGENT_CONFIG_FILES[agentState.agent]?.label ?? agentState.agent;
-            console.log(`    ${label.padEnd(16)} ${agentState.state}${agentState.detail ? ` (${agentState.detail})` : ''}`);
+            chunks.push(`    ${label.padEnd(16)} ${agentState.state}${agentState.detail ? ` (${agentState.detail})` : ''}`);
+        }
+        const details = report.integrationDetails.find((detail) => detail.key === integration.key);
+        chunks.push(`    hooks allowed: ${details?.hooksAllowed ? 'yes' : 'no'}`);
+        chunks.push(`    external requests allowed: ${details?.externalRequestsAllowed ? 'yes' : 'no'}`);
+        for (const warning of details?.warnings ?? []) {
+            chunks.push(theme.warn(`    warning: ${warning}`));
         }
-        console.log(`    hooks allowed: ${superpowersConfig.allow_hooks ? 'yes' : 'no'}`);
-        console.log(`    external requests allowed: ${superpowersConfig.allow_external_requests ? 'yes' : 'no'}`);
-        for (const warning of result.warnings)
-            console.log(theme.warn(`    warning: ${warning}`));
     }
-    console.log(theme.heading('\n=== Status complete ===\n'));
+    return chunks.join('\n') + '\n';
+}
+export const statusCommand = new Command()
+    .name('status')
+    .description('Show current configuration and environment status')
+    .option('--json', 'emit a machine-readable JSON document on stdout')
+    .option('--short', 'collapsed one-line-per-area report (no per-item detail)')
+    .action(async (options) => {
+    const json = options.json === true;
+    const short = options.short === true;
+    if (json)
+        setQuietEnabled(true);
+    renderLogo();
+    const report = await gatherStatus();
+    if (json) {
+        console.log(JSON.stringify(statusToJson(report), null, 2));
+    }
+    else {
+        process.stdout.write(short ? renderStatusShort(report) : renderStatus(report));
+        const summary = statusSummary(report);
+        console.log(resolveResultLine(summary));
+    }
+    if (report.exitCode === 1)
+        process.exitCode = 1;
 });
 //# sourceMappingURL=status.js.map