orbital-command 0.1.4 → 0.3.0

package/dist/server/server/wizard/doctor.js

@@ -0,0 +1,115 @@
+/**
+ * Health diagnostics — `orbital doctor`
+ */
+import fs from 'fs';
+import path from 'path';
+import { execFileSync } from 'child_process';
+import pc from 'picocolors';
+export async function runDoctor(projectRoot, packageVersion) {
+    console.log(`\n  ${pc.bold('Orbital Command')} ${pc.cyan(`v${packageVersion}`)}\n`);
+    const checks = [];
+    // 1. Check for latest version on npm
+    try {
+        const latest = execFileSync('npm', ['view', 'orbital-command', 'version'], {
+            encoding: 'utf8',
+            timeout: 5000,
+        }).trim();
+        if (latest && latest !== packageVersion) {
+            checks.push({ label: 'Latest', status: pc.yellow(`v${latest} available (run \`npm update -g orbital-command\`)`) });
+        }
+        else {
+            checks.push({ label: 'Latest', status: pc.green(`v${packageVersion} (up to date)`) });
+        }
+    }
+    catch {
+        checks.push({ label: 'Latest', status: pc.dim('could not check (npm unreachable)') });
+    }
+    // 2. Node version
+    const nodeVersion = process.version;
+    const major = parseInt(nodeVersion.slice(1), 10);
+    if (major >= 18) {
+        checks.push({ label: 'Node', status: pc.green(`${nodeVersion} (supported)`) });
+    }
+    else {
+        checks.push({ label: 'Node', status: pc.red(`${nodeVersion} (requires Node 18+)`) });
+    }
+    // 3. Global registry
+    const homedir = process.env.HOME || process.env.USERPROFILE || '~';
+    const registryPath = path.join(homedir, '.orbital', 'config.json');
+    if (fs.existsSync(registryPath)) {
+        try {
+            const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
+            const count = (registry.projects || []).length;
+            checks.push({ label: 'Global', status: pc.green(`~/.orbital/ exists (${count} project${count !== 1 ? 's' : ''} registered)`) });
+        }
+        catch {
+            checks.push({ label: 'Global', status: pc.yellow('~/.orbital/ exists (registry unreadable)') });
+        }
+    }
+    else {
+        checks.push({ label: 'Global', status: pc.dim('~/.orbital/ not found (run `orbital init` to create)') });
+    }
+    // 4. Project initialization
+    const configPath = path.join(projectRoot, '.claude', 'orbital.config.json');
+    if (fs.existsSync(configPath)) {
+        try {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            const name = config.projectName || path.basename(projectRoot);
+            checks.push({ label: 'Project', status: pc.green(`initialized (${name})`) });
+        }
+        catch {
+            checks.push({ label: 'Project', status: pc.yellow('config exists but unreadable') });
+        }
+    }
+    else {
+        checks.push({ label: 'Project', status: pc.dim('not initialized (run `orbital init`)') });
+    }
+    // 5. Workflow
+    const workflowPath = path.join(projectRoot, '.claude', 'config', 'workflow.json');
+    if (fs.existsSync(workflowPath)) {
+        try {
+            const wf = JSON.parse(fs.readFileSync(workflowPath, 'utf8'));
+            const listCount = (wf.lists || []).length;
+            const mode = wf.branchingMode || 'unknown';
+            checks.push({ label: 'Workflow', status: pc.green(`${wf.name || 'Custom'} (${listCount} lists, ${mode})`) });
+        }
+        catch {
+            checks.push({ label: 'Workflow', status: pc.yellow('workflow.json exists but unreadable') });
+        }
+    }
+    else {
+        checks.push({ label: 'Workflow', status: pc.dim('no workflow configured') });
+    }
+    // 6. Database
+    const dbPath = path.join(projectRoot, '.claude', 'orbital', 'orbital.db');
+    if (fs.existsSync(dbPath)) {
+        const stats = fs.statSync(dbPath);
+        const sizeMb = (stats.size / (1024 * 1024)).toFixed(1);
+        checks.push({ label: 'Database', status: pc.green(`${sizeMb} MB`) });
+    }
+    else {
+        checks.push({ label: 'Database', status: pc.dim('not yet created (starts on first launch)') });
+    }
+    // 7. Template staleness
+    if (fs.existsSync(configPath)) {
+        try {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            if (config.templateVersion && config.templateVersion !== packageVersion) {
+                checks.push({ label: 'Templates', status: pc.yellow(`outdated (v${config.templateVersion} → v${packageVersion}, run \`orbital update\`)`) });
+            }
+            else if (config.templateVersion) {
+                checks.push({ label: 'Templates', status: pc.green('synced') });
+            }
+            else {
+                checks.push({ label: 'Templates', status: pc.yellow('no version stamp (run `orbital update`)') });
+            }
+        }
+        catch { /* skip */ }
+    }
+    // Print all checks
+    const maxLabel = Math.max(...checks.map(c => c.label.length));
+    for (const check of checks) {
+        console.log(`  ${pc.dim(check.label.padEnd(maxLabel + 2))} ${check.status}`);
+    }
+    console.log();
+}

package/dist/server/server/wizard/index.js

@@ -0,0 +1,155 @@
+/**
+ * Interactive CLI wizard — main orchestrator.
+ *
+ * Entry points:
+ *   runSetupWizard()   — Phase 1: first-time Orbital setup (~/.orbital/)
+ *   runProjectSetup()  — Phase 2: per-project scaffolding (.claude/)
+ *   runConfigEditor()  — interactive config editor (orbital config)
+ *   runDoctor()        — health diagnostics (orbital doctor)
+ */
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { buildSetupState, buildProjectState, ORBITAL_HOME } from './detect.js';
+import { phaseSetupWizard } from './phases/setup-wizard.js';
+import { phaseWelcome } from './phases/welcome.js';
+import { phaseProjectSetup } from './phases/project-setup.js';
+import { phaseWorkflowSetup } from './phases/workflow-setup.js';
+import { phaseConfirm, showPostInstall } from './phases/confirm.js';
+import { NOTES } from './ui.js';
+import { runConfigEditor } from './config-editor.js';
+import { runDoctor } from './doctor.js';
+export { runConfigEditor, runDoctor };
+// ─── Phase 1: Setup Wizard ─────────────────────────────────────
+/**
+ * First-time setup. Creates ~/.orbital/, seeds primitives,
+ * optionally links projects (running Phase 2 for each).
+ */
+export async function runSetupWizard(packageVersion) {
+    const state = buildSetupState(packageVersion);
+    p.intro(`${pc.bgCyan(pc.black(' Orbital Command '))} ${pc.dim(`v${packageVersion}`)}`);
+    await phaseSetupWizard(state);
+    // If user linked projects, run Phase 2 for each
+    for (const projectRoot of state.linkedProjects) {
+        p.log.step(`Setting up ${pc.cyan(path.basename(projectRoot))}...`);
+        await runProjectSetupInline(projectRoot, packageVersion);
+    }
+    if (state.linkedProjects.length === 0) {
+        p.note(NOTES.setupComplete, 'Done');
+    }
+    p.outro(state.linkedProjects.length > 0
+        ? `Run ${pc.cyan('orbital launch --open')} to open the dashboard.`
+        : `Run ${pc.cyan('orbital init')} in a project directory to get started.`);
+}
+// ─── Phase 2: Project Setup ────────────────────────────────────
+/**
+ * Per-project setup. Walks through name, commands, workflow, then
+ * calls runInit() to scaffold files into .claude/.
+ */
+export async function runProjectSetup(projectRoot, packageVersion, args) {
+    const state = buildProjectState(projectRoot, packageVersion);
+    const force = args.includes('--force');
+    p.intro(`${pc.bgCyan(pc.black(' Orbital Command '))} ${pc.dim(`v${packageVersion}`)}`);
+    // Welcome gate: detect re-init / reconfigure
+    const forceFromWelcome = await phaseWelcome(state);
+    const useForce = force || forceFromWelcome;
+    await runProjectPhases(state, useForce);
+    p.outro(`Run ${pc.cyan('orbital launch --open')} to open the dashboard.`);
+}
+// ─── Shared project phases (used by both flows) ────────────────
+/**
+ * Run the project setup phases and install. Used by both
+ * standalone runProjectSetup() and inline from runSetupWizard().
+ */
+async function runProjectPhases(state, useForce) {
+    await phaseProjectSetup(state);
+    await phaseWorkflowSetup(state);
+    await phaseConfirm(state);
+    // Install
+    const s = p.spinner();
+    s.start('Installing into project...');
+    try {
+        const { runInit } = await import('../init.js');
+        runInit(state.projectRoot, {
+            force: useForce,
+            quiet: true,
+            preset: state.workflowPreset,
+            projectName: state.projectName,
+            serverPort: state.serverPort,
+            clientPort: state.clientPort,
+            commands: state.selectedCommands,
+        });
+        registerProject(state.projectRoot, state.projectName);
+        stampTemplateVersion(state.projectRoot, state.packageVersion);
+        s.stop('Project ready.');
+    }
+    catch (err) {
+        s.stop('Installation failed.');
+        p.log.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+    showPostInstall(state);
+}
+/**
+ * Inline project setup — called from Phase 1 when user links a project.
+ * Skips intro/outro since the setup wizard already has those.
+ */
+async function runProjectSetupInline(projectRoot, packageVersion) {
+    const state = buildProjectState(projectRoot, packageVersion);
+    // Skip welcome gate for inline — this is a fresh project being linked
+    await runProjectPhases(state, false);
+}
+// ─── Registration ──────────────────────────────────────────────
+function registerProject(projectRoot, projectName) {
+    const registryPath = path.join(ORBITAL_HOME, 'config.json');
+    let registry;
+    try {
+        registry = fs.existsSync(registryPath)
+            ? JSON.parse(fs.readFileSync(registryPath, 'utf8'))
+            : { version: 1, projects: [] };
+    }
+    catch {
+        registry = { version: 1, projects: [] };
+    }
+    if (!registry.projects)
+        registry.projects = [];
+    if (registry.projects.some((proj) => proj.path === projectRoot))
+        return;
+    const COLORS = [
+        '210 80% 55%', '340 75% 55%', '160 60% 45%', '30 90% 55%',
+        '270 65% 55%', '50 85% 50%', '180 55% 45%', '0 70% 55%',
+    ];
+    const usedColors = registry.projects.map((proj) => proj.color);
+    const color = COLORS.find(c => !usedColors.includes(c)) || COLORS[0];
+    const name = projectName || path.basename(projectRoot);
+    const baseSlug = path.basename(projectRoot).toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '') || 'project';
+    const existingIds = registry.projects.map((proj) => proj.id);
+    const slug = existingIds.includes(baseSlug)
+        ? `${baseSlug}-${crypto.createHash('sha256').update(projectRoot).digest('hex').slice(0, 4)}`
+        : baseSlug;
+    registry.projects.push({
+        id: slug,
+        path: projectRoot,
+        name,
+        color,
+        registeredAt: new Date().toISOString(),
+        enabled: true,
+    });
+    fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2), 'utf8');
+}
+// ─── Template Version Stamping ─────────────────────────────────
+function stampTemplateVersion(projectRoot, packageVersion) {
+    const configPath = path.join(projectRoot, '.claude', 'orbital.config.json');
+    if (!fs.existsSync(configPath))
+        return;
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        if (config.templateVersion !== packageVersion) {
+            config.templateVersion = packageVersion;
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+        }
+    }
+    catch { /* ignore malformed config */ }
+}

package/dist/server/server/wizard/phases/confirm.js

@@ -0,0 +1,39 @@
+/**
+ * Phase 3: Confirm choices, run installation, show next steps.
+ */
+import fs from 'fs';
+import path from 'path';
+import * as p from '@clack/prompts';
+import { NOTES, formatSummary } from '../ui.js';
+export async function phaseConfirm(state) {
+    p.note(formatSummary(state), 'Ready to Initialize');
+    const proceed = await p.confirm({
+        message: 'Proceed with installation?',
+        initialValue: true,
+    });
+    if (p.isCancel(proceed) || !proceed) {
+        p.cancel('Setup cancelled.');
+        process.exit(0);
+    }
+}
+export function showPostInstall(state) {
+    // Count installed artifacts
+    const claudeDir = path.join(state.projectRoot, '.claude');
+    const counts = {
+        hooks: countDir(path.join(claudeDir, 'hooks')),
+        skills: countDir(path.join(claudeDir, 'skills')),
+        agents: countDir(path.join(claudeDir, 'agents')),
+    };
+    p.note(NOTES.postInstall(counts), 'Installation Complete');
+    p.note(NOTES.nextSteps, 'Getting Started');
+}
+function countDir(dir) {
+    if (!fs.existsSync(dir))
+        return 0;
+    try {
+        return fs.readdirSync(dir).filter(f => !f.startsWith('.')).length;
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/server/server/wizard/phases/project-setup.js

@@ -0,0 +1,90 @@
+/**
+ * Phase 1: Project configuration — name, commands, ports.
+ */
+import * as p from '@clack/prompts';
+import { NOTES, formatDetectedCommands } from '../ui.js';
+import { detectProjectName, detectCommands, detectPortConflict } from '../detect.js';
+export async function phaseProjectSetup(state) {
+    p.note(NOTES.projectConfig, 'Project Configuration');
+    // 1. Project name
+    const defaultName = detectProjectName(state.projectRoot);
+    const name = await p.text({
+        message: 'Project name',
+        placeholder: defaultName,
+        defaultValue: defaultName,
+    });
+    if (p.isCancel(name)) {
+        p.cancel('Setup cancelled.');
+        process.exit(0);
+    }
+    state.projectName = name;
+    // 2. Command detection
+    const detected = detectCommands(state.projectRoot);
+    state.detectedCommands = detected;
+    const detectedCount = Object.values(detected).filter(v => v !== null).length;
+    if (detectedCount > 0) {
+        p.note(formatDetectedCommands(detected), `Detected ${detectedCount} command(s) from package.json`);
+        const useDetected = await p.confirm({
+            message: 'Use these detected commands for quality gates?',
+            initialValue: true,
+        });
+        if (p.isCancel(useDetected)) {
+            p.cancel('Setup cancelled.');
+            process.exit(0);
+        }
+        if (useDetected) {
+            state.selectedCommands = { ...detected };
+        }
+        else {
+            state.selectedCommands = await promptCommands(detected);
+        }
+    }
+    else {
+        p.log.info('No build commands detected from package.json. You can configure them later with `orbital config`.');
+        state.selectedCommands = detected;
+    }
+    // 3. Port conflict detection
+    const conflict = detectPortConflict(4444);
+    if (conflict) {
+        p.log.warn(`Port 4444 is already used by "${conflict}".`);
+        const serverPort = await p.text({
+            message: 'Server port',
+            placeholder: '4446',
+            defaultValue: '4446',
+            validate: (val) => {
+                const n = Number(val);
+                if (isNaN(n) || n < 1 || n > 65535)
+                    return 'Must be a valid port (1-65535)';
+                return undefined;
+            },
+        });
+        if (p.isCancel(serverPort)) {
+            p.cancel('Setup cancelled.');
+            process.exit(0);
+        }
+        state.serverPort = Number(serverPort);
+        state.clientPort = state.serverPort + 1;
+    }
+}
+async function promptCommands(defaults) {
+    const commands = {};
+    const labels = {
+        typeCheck: 'Type check command',
+        lint: 'Lint command',
+        build: 'Build command',
+        test: 'Test command',
+    };
+    for (const [key, defaultVal] of Object.entries(defaults)) {
+        const val = await p.text({
+            message: labels[key] || key,
+            placeholder: defaultVal || 'none',
+            defaultValue: defaultVal || '',
+        });
+        if (p.isCancel(val)) {
+            p.cancel('Setup cancelled.');
+            process.exit(0);
+        }
+        commands[key] = val || null;
+    }
+    return commands;
+}

package/dist/server/server/wizard/phases/setup-wizard.js

@@ -0,0 +1,66 @@
+/**
+ * Phase 1: Setup Wizard — runs on first install or when ~/.orbital/ is missing.
+ *
+ * Creates the Orbital home directory, seeds primitives, and optionally
+ * lets the user link projects immediately.
+ */
+import fs from 'fs';
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { NOTES } from '../ui.js';
+import { isValidProjectPath, resolveProjectPath, ORBITAL_HOME } from '../detect.js';
+export async function phaseSetupWizard(state) {
+    // Welcome and core concepts
+    p.note(NOTES.setupWelcome, 'Welcome');
+    // Create ~/.orbital/ and seed primitives
+    const s = p.spinner();
+    s.start('Setting up Orbital Command...');
+    try {
+        const { ensureOrbitalHome } = await import('../../global-config.js');
+        const { seedGlobalPrimitives } = await import('../../init.js');
+        ensureOrbitalHome();
+        seedGlobalPrimitives();
+        // Create empty registry if it doesn't exist
+        const registryPath = `${ORBITAL_HOME}/config.json`;
+        if (!fs.existsSync(registryPath)) {
+            fs.writeFileSync(registryPath, JSON.stringify({ version: 1, projects: [] }, null, 2), 'utf8');
+        }
+        s.stop('Orbital Command is ready.');
+    }
+    catch (err) {
+        s.stop('Setup failed.');
+        p.log.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+    // Offer to link projects
+    p.note(NOTES.addProject, 'Projects');
+    let addMore = true;
+    while (addMore) {
+        const wantsProject = await p.confirm({
+            message: state.linkedProjects.length === 0
+                ? 'Add a project now?'
+                : 'Add another project?',
+            initialValue: state.linkedProjects.length === 0,
+        });
+        if (p.isCancel(wantsProject) || !wantsProject) {
+            addMore = false;
+            break;
+        }
+        const projectPath = await p.text({
+            message: 'Project path',
+            placeholder: '~/Code/my-project',
+            validate: (val) => {
+                if (!val || !val.trim())
+                    return 'Path is required';
+                return isValidProjectPath(val.trim());
+            },
+        });
+        if (p.isCancel(projectPath)) {
+            addMore = false;
+            break;
+        }
+        const resolved = resolveProjectPath(projectPath.trim());
+        state.linkedProjects.push(resolved);
+        p.log.success(`Added: ${pc.cyan(resolved)}`);
+    }
+}

package/dist/server/server/wizard/phases/welcome.js

@@ -0,0 +1,35 @@
+/**
+ * Phase 2 welcome gate — project-scoped only.
+ *
+ * If the project is already initialized, offers re-init or config editor.
+ * If not, returns false to continue the project setup flow.
+ */
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { NOTES } from '../ui.js';
+import { runConfigEditor } from '../config-editor.js';
+export async function phaseWelcome(state) {
+    if (state.isProjectInitialized) {
+        p.note(NOTES.reconfigure, pc.yellow('Already Initialized'));
+        const action = await p.select({
+            message: 'What would you like to do?',
+            options: [
+                { value: 'reinit', label: 'Re-initialize (--force)', hint: 'reset all templates to defaults' },
+                { value: 'configure', label: 'Open config editor', hint: 'modify settings without resetting' },
+                { value: 'cancel', label: 'Cancel' },
+            ],
+        });
+        if (p.isCancel(action) || action === 'cancel') {
+            p.cancel('Cancelled.');
+            process.exit(0);
+        }
+        if (action === 'configure') {
+            await runConfigEditor(state.projectRoot, state.packageVersion, []);
+            process.exit(0);
+        }
+        // Re-init — continue through the full project setup with force
+        return true;
+    }
+    // Not initialized — continue normally
+    return false;
+}

package/dist/server/server/wizard/phases/workflow-setup.js

@@ -0,0 +1,22 @@
+/**
+ * Phase 2: Workflow preset selection.
+ */
+import * as p from '@clack/prompts';
+import { WORKFLOW_PRESETS } from '../types.js';
+import { NOTES } from '../ui.js';
+export async function phaseWorkflowSetup(state) {
+    p.note(NOTES.workflow, 'Workflow Selection');
+    const preset = await p.select({
+        message: 'Choose a workflow preset',
+        options: WORKFLOW_PRESETS.map(p => ({
+            value: p.value,
+            label: p.label,
+            hint: p.hint,
+        })),
+    });
+    if (p.isCancel(preset)) {
+        p.cancel('Setup cancelled.');
+        process.exit(0);
+    }
+    state.workflowPreset = preset;
+}

package/dist/server/server/wizard/types.js

@@ -0,0 +1,29 @@
+/**
+ * Types for the interactive CLI wizard.
+ *
+ * Two wizard flows:
+ *   Phase 1 (SetupState)        — first-time Orbital setup, ~/.orbital/ creation
+ *   Phase 2 (ProjectSetupState) — per-project scaffolding into .claude/
+ */
+export const WORKFLOW_PRESETS = [
+    {
+        value: 'default',
+        label: 'Default',
+        hint: '7 lists, trunk-based — Icebox → Planning → Backlog → Implementing → Review → Completed → Main',
+    },
+    {
+        value: 'minimal',
+        label: 'Minimal',
+        hint: '3 lists — To Do → In Progress → Done',
+    },
+    {
+        value: 'development',
+        label: 'Development',
+        hint: '5 lists, dev branch — Backlog → Implementing → Review → Completed → Dev',
+    },
+    {
+        value: 'gitflow',
+        label: 'Gitflow',
+        hint: '9 lists, multi-branch — Full pipeline with Dev, Staging, and Production',
+    },
+];

package/dist/server/server/wizard/ui.js

@@ -0,0 +1,74 @@
+/**
+ * Shared UI helpers, concept notes, and formatting for the wizard.
+ */
+import pc from 'picocolors';
+// ─── Concept Notes ──────────────────────────────────────────────
+export const NOTES = {
+    // Phase 1: Setup wizard (runs on install / first use)
+    setupWelcome: `Orbital Command is a mission control layer for Claude Code.
+
+It gives your projects a real-time dashboard with a Kanban board,
+${pc.cyan('scopes')} (work items), ${pc.cyan('workflow stages')}, ${pc.cyan('quality gates')},
+${pc.cyan('dispatches')} (automated Claude sessions), and a ${pc.cyan('sprint orchestrator')}.
+
+Everything is driven by config files and hooks inside your project's
+${pc.cyan('.claude/')} directory — no database or external service required.`,
+    setupComplete: `${pc.bold('Setup complete.')}
+
+  ${pc.cyan('orbital init')}            Add a project (run in a project directory)
+  ${pc.cyan('orbital launch --open')}   Start the dashboard
+  ${pc.cyan('orbital doctor')}          Health check & version info`,
+    addProject: `You can add projects now or later with ${pc.cyan('orbital init')}.
+Each project gets its own workflow, scopes, and quality gates.`,
+    // Phase 2: Project setup (runs per-project)
+    reconfigure: `This project is already initialized with Orbital Command.
+You can reconfigure settings or run ${pc.cyan('orbital init --force')} to reset.`,
+    projectConfig: `${pc.bold('Project Config')} ${pc.dim('(.claude/orbital.config.json)')}
+
+Each project gets its own config inside ${pc.cyan('.claude/')}. The project
+config controls the name shown in the dashboard, ports, build commands
+used by quality gates, and agent definitions.`,
+    workflow: `${pc.bold('Workflows')} ${pc.dim('(Scopes, Lists, Dispatches)')}
+
+Orbital organizes work into ${pc.cyan('scopes')} (cards) that move through
+${pc.cyan('lists')} (Kanban columns). Transitions between lists can trigger
+commands, quality gates, and Claude Code sessions (${pc.cyan('dispatches')}).
+
+Choose a preset to start — you can customize it later from the
+dashboard's workflow editor or by editing ${pc.cyan('.claude/config/workflow.json')}.`,
+    postInstall: (counts) => `${pc.bold('What was just created')}
+
+${pc.cyan('Hooks')} (${counts.hooks})     Lifecycle scripts that enforce rules on transitions
+${pc.cyan('Skills')} (${counts.skills})    Slash commands for Claude (/scope-create, /git-commit, etc.)
+${pc.cyan('Agents')} (${counts.agents})    Team specifications for code review, architecture, security
+${pc.cyan('Workflow')}      Your selected preset defining lists and transitions
+${pc.cyan('Quality Gates')}  Automated checks (lint, typecheck, tests) before transitions`,
+    nextSteps: `${pc.bold('Next Steps')}
+
+  1. ${pc.cyan('orbital launch --open')}   Open the dashboard
+  2. Create a scope from the board or use ${pc.cyan('/scope-create')}
+  3. Use ${pc.cyan('/scope-implement')} to start working on a scope
+
+${pc.bold('Useful Commands')}
+
+  ${pc.cyan('orbital status')}    See template sync status
+  ${pc.cyan('orbital config')}    Modify project settings
+  ${pc.cyan('orbital update')}    Sync to latest templates
+  ${pc.cyan('orbital doctor')}    Health check & version info`,
+};
+// ─── Formatting Helpers ─────────────────────────────────────────
+export function formatDetectedCommands(commands) {
+    const entries = Object.entries(commands).filter(([, v]) => v !== null);
+    if (entries.length === 0)
+        return pc.dim('  No commands detected');
+    return entries
+        .map(([key, val]) => `  ${pc.cyan(key.padEnd(12))} ${val}`)
+        .join('\n');
+}
+export function formatSummary(state) {
+    return [
+        `  Project:    ${pc.cyan(state.projectName || 'Unknown')}`,
+        `  Workflow:   ${pc.cyan(state.workflowPreset || 'default')}`,
+        `  Ports:      ${pc.cyan(String(state.serverPort || 4444))} (server) / ${pc.cyan(String(state.clientPort || 4445))} (client)`,
+    ].join('\n');
+}