orbital-command 0.3.0 → 1.0.0

package/dist/server/server/utils/route-helpers.test.js

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest';
+import express from 'express';
+import request from 'supertest';
+import { errMsg, isValidRelativePath, inferErrorStatus, catchRoute } from './route-helpers.js';
+// ─── errMsg ─────────────────────────────────────────────────
+describe('errMsg', () => {
+    it('extracts message from Error instances', () => {
+        expect(errMsg(new Error('something broke'))).toBe('something broke');
+    });
+    it('converts non-Error values to strings', () => {
+        expect(errMsg('raw string')).toBe('raw string');
+        expect(errMsg(42)).toBe('42');
+        expect(errMsg(null)).toBe('null');
+        expect(errMsg(undefined)).toBe('undefined');
+    });
+});
+// ─── isValidRelativePath ────────────────────────────────────
+describe('isValidRelativePath', () => {
+    it('accepts normal relative paths', () => {
+        expect(isValidRelativePath('hooks/init.sh')).toBe(true);
+        expect(isValidRelativePath('agents/attacker/AGENT.md')).toBe(true);
+        expect(isValidRelativePath('file.txt')).toBe(true);
+    });
+    it('rejects directory traversal', () => {
+        expect(isValidRelativePath('../etc/passwd')).toBe(false);
+        expect(isValidRelativePath('hooks/../../secret')).toBe(false);
+    });
+    it('rejects absolute paths', () => {
+        expect(isValidRelativePath('/etc/passwd')).toBe(false);
+    });
+    it('rejects null bytes', () => {
+        expect(isValidRelativePath('file\0.txt')).toBe(false);
+    });
+});
+// ─── inferErrorStatus ───────────────────────────────────────
+describe('inferErrorStatus', () => {
+    it('returns 403 for traversal errors', () => {
+        expect(inferErrorStatus('Path traversal detected')).toBe(403);
+        expect(inferErrorStatus('directory traversal not allowed')).toBe(403);
+    });
+    it('returns 404 for not-found errors', () => {
+        expect(inferErrorStatus('File not found')).toBe(404);
+        expect(inferErrorStatus('ENOENT: no such file')).toBe(404);
+    });
+    it('returns 409 for already-exists errors', () => {
+        expect(inferErrorStatus('File already exists at path')).toBe(409);
+    });
+    it('returns 400 for directory errors', () => {
+        expect(inferErrorStatus('Cannot delete directory')).toBe(400);
+    });
+    it('returns 500 for unrecognized errors', () => {
+        expect(inferErrorStatus('something unexpected')).toBe(500);
+        expect(inferErrorStatus('')).toBe(500);
+    });
+    it('matches the first keyword when multiple are present', () => {
+        // "traversal" comes first in the chain, should win
+        expect(inferErrorStatus('traversal not found')).toBe(403);
+    });
+});
+// ─── catchRoute ─────────────────────────────────────────────
+describe('catchRoute', () => {
+    function createApp(handler) {
+        const app = express();
+        app.get('/test', handler);
+        return app;
+    }
+    it('returns normal response when handler succeeds', async () => {
+        const app = createApp(catchRoute((_req, res) => {
+            res.json({ ok: true });
+        }));
+        const res = await request(app).get('/test');
+        expect(res.status).toBe(200);
+        expect(res.body).toEqual({ ok: true });
+    });
+    it('catches sync throws and returns 500', async () => {
+        const app = createApp(catchRoute(() => {
+            throw new Error('sync failure');
+        }));
+        const res = await request(app).get('/test');
+        expect(res.status).toBe(500);
+        expect(res.body).toEqual({ success: false, error: 'sync failure' });
+    });
+    it('catches async throws and returns 500', async () => {
+        const app = createApp(catchRoute(async () => {
+            throw new Error('async failure');
+        }));
+        const res = await request(app).get('/test');
+        expect(res.status).toBe(500);
+        expect(res.body).toEqual({ success: false, error: 'async failure' });
+    });
+    it('uses custom statusFn for error status codes', async () => {
+        const app = createApp(catchRoute(() => {
+            throw new Error('File not found at path');
+        }, inferErrorStatus));
+        const res = await request(app).get('/test');
+        expect(res.status).toBe(404);
+        expect(res.body).toEqual({ success: false, error: 'File not found at path' });
+    });
+    it('uses custom statusFn for traversal errors', async () => {
+        const app = createApp(catchRoute(() => {
+            throw new Error('Path traversal detected');
+        }, inferErrorStatus));
+        const res = await request(app).get('/test');
+        expect(res.status).toBe(403);
+    });
+    it('handles non-Error thrown values', async () => {
+        const app = createApp(catchRoute(() => {
+            // eslint-disable-next-line no-throw-literal
+            throw 'raw string error';
+        }));
+        const res = await request(app).get('/test');
+        expect(res.status).toBe(500);
+        expect(res.body).toEqual({ success: false, error: 'raw string error' });
+    });
+});

package/dist/server/server/watchers/event-watcher.js

@@ -5,6 +5,7 @@ import { parseEventFile } from '../parsers/event-parser.js';
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('event');
 const ARCHIVE_DIR_NAME = 'processed';
+const processingFiles = new Set();
 /**
  * Watch .claude/orbital-events/ for new JSON event files.
  * On startup, processes any existing unprocessed events.
@@ -59,23 +60,37 @@ function processExistingEvents(eventsDir, eventService, archiveDir) {
     }
 }
 function processEventFile(filePath, eventService, archiveDir) {
-    const event = parseEventFile(filePath);
-    if (!event)
+    if (processingFiles.has(filePath))
         return;
-    eventService.ingest(event);
-    // Move to archive
-    const fileName = path.basename(filePath);
+    processingFiles.add(filePath);
     try {
-        fs.renameSync(filePath, path.join(archiveDir, fileName));
-    }
-    catch (err) {
-        log.warn('Failed to archive event file', { file: filePath, error: err.message });
-        // If rename fails (cross-device), just delete the source
+        const event = parseEventFile(filePath);
+        if (!event)
+            return;
+        eventService.ingest(event);
+        // Move to archive
+        const fileName = path.basename(filePath);
         try {
-            fs.unlinkSync(filePath);
+            fs.renameSync(filePath, path.join(archiveDir, fileName));
         }
-        catch (unlinkErr) {
-            log.warn('Failed to delete event file', { file: filePath, error: unlinkErr.message });
+        catch (err) {
+            const code = err.code;
+            if (code === 'ENOENT')
+                return; // Already archived by concurrent handler
+            log.warn('Failed to archive event file', { file: filePath, error: err.message });
+            // If rename fails (cross-device), just delete the source
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch (unlinkErr) {
+                const unlinkCode = unlinkErr.code;
+                if (unlinkCode !== 'ENOENT') {
+                    log.warn('Failed to delete event file', { file: filePath, error: unlinkErr.message });
+                }
+            }
         }
     }
+    finally {
+        processingFiles.delete(filePath);
+    }
 }

package/dist/server/server/wizard/config-editor.js

@@ -12,7 +12,7 @@ export async function runConfigEditor(projectRoot, packageVersion, args) {
     if (subcommand === 'show') {
         const config = loadProjectConfig(projectRoot);
         if (!config) {
-            console.error('No config found. Run `orbital init` first.');
+            console.error('No config found. Run `orbital` first.');
             process.exit(1);
         }
         console.log(JSON.stringify(config, null, 2));
@@ -32,7 +32,7 @@ export async function runConfigEditor(projectRoot, packageVersion, args) {
     // Interactive mode
     const config = loadProjectConfig(projectRoot);
     if (!config) {
-        p.log.error('No config found. Run `orbital init` first.');
+        p.log.error('No config found. Run `orbital` first.');
         process.exit(1);
     }
     p.intro(`${pc.bgCyan(pc.black(' Orbital Config '))} ${pc.dim(`v${packageVersion}`)}`);
@@ -158,7 +158,7 @@ async function editGlobalSection() {
     const homedir = process.env.HOME || process.env.USERPROFILE || '~';
     const registryPath = path.join(homedir, '.orbital', 'config.json');
     if (!fs.existsSync(registryPath)) {
-        p.log.info('No global registry found. Run `orbital init` in a project first.');
+        p.log.info('No global registry found. Run `orbital` in a project first.');
         return;
     }
     try {
@@ -198,7 +198,7 @@ function saveProjectConfig(projectRoot, config) {
 function setConfigValue(projectRoot, key, value) {
     const config = loadProjectConfig(projectRoot);
     if (!config) {
-        console.error('No config found. Run `orbital init` first.');
+        console.error('No config found. Run `orbital` first.');
         process.exit(1);
     }
     // Parse value: try number, then boolean, then string

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

@@ -47,7 +47,7 @@ export async function runDoctor(projectRoot, packageVersion) {
         }
     }
     else {
-        checks.push({ label: 'Global', status: pc.dim('~/.orbital/ not found (run `orbital init` to create)') });
+        checks.push({ label: 'Global', status: pc.dim('~/.orbital/ not found (run `orbital` to create)') });
     }
     // 4. Project initialization
     const configPath = path.join(projectRoot, '.claude', 'orbital.config.json');
@@ -62,7 +62,7 @@ export async function runDoctor(projectRoot, packageVersion) {
         }
     }
     else {
-        checks.push({ label: 'Project', status: pc.dim('not initialized (run `orbital init`)') });
+        checks.push({ label: 'Project', status: pc.dim('not initialized (run `orbital`)') });
     }
     // 5. Workflow
     const workflowPath = path.join(projectRoot, '.claude', 'config', 'workflow.json');

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

@@ -9,10 +9,10 @@
  */
 import fs from 'fs';
 import path from 'path';
-import crypto from 'crypto';
+import { spawn, execFileSync } from 'child_process';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
-import { buildSetupState, buildProjectState, ORBITAL_HOME } from './detect.js';
+import { buildSetupState, buildProjectState } from './detect.js';
 import { phaseSetupWizard } from './phases/setup-wizard.js';
 import { phaseWelcome } from './phases/welcome.js';
 import { phaseProjectSetup } from './phases/project-setup.js';
@@ -21,6 +21,8 @@ import { phaseConfirm, showPostInstall } from './phases/confirm.js';
 import { NOTES } from './ui.js';
 import { runConfigEditor } from './config-editor.js';
 import { runDoctor } from './doctor.js';
+import { isITerm2Available } from '../adapters/iterm2-adapter.js';
+import { registerProject } from '../global-config.js';
 export { runConfigEditor, runDoctor };
 // ─── Phase 1: Setup Wizard ─────────────────────────────────────
 /**
@@ -40,8 +42,8 @@ export async function runSetupWizard(packageVersion) {
         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.`);
+        ? `Run ${pc.cyan('orbital')} to launch the dashboard.`
+        : `Run ${pc.cyan('orbital')} in a project directory to get started.`);
 }
 // ─── Phase 2: Project Setup ────────────────────────────────────
 /**
@@ -56,7 +58,7 @@ export async function runProjectSetup(projectRoot, packageVersion, args) {
     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.`);
+    p.outro(`Run ${pc.cyan('orbital')} to launch the dashboard.`);
 }
 // ─── Shared project phases (used by both flows) ────────────────
 /**
@@ -81,7 +83,7 @@ async function runProjectPhases(state, useForce) {
             clientPort: state.clientPort,
             commands: state.selectedCommands,
         });
-        registerProject(state.projectRoot, state.projectName);
+        registerProject(state.projectRoot, { name: state.projectName });
         stampTemplateVersion(state.projectRoot, state.packageVersion);
         s.stop('Project ready.');
     }
@@ -101,43 +103,224 @@ async function runProjectSetupInline(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;
+async function checkForUpdate(currentVersion, cache) {
+    // Use cache if checked within 24 hours
+    if (cache.lastUpdateCheck && cache.latestVersion) {
+        const age = Date.now() - new Date(cache.lastUpdateCheck).getTime();
+        if (age < 24 * 60 * 60 * 1000) {
+            const isOutdated = cache.latestVersion !== currentVersion;
+            return {
+                info: { current: currentVersion, latest: cache.latestVersion, isOutdated },
+                cacheChanged: false,
+            };
+        }
+    }
+    // Fetch from npm registry
     try {
-        registry = fs.existsSync(registryPath)
-            ? JSON.parse(fs.readFileSync(registryPath, 'utf8'))
-            : { version: 1, projects: [] };
+        const res = await fetch('https://registry.npmjs.org/orbital-command/latest', {
+            signal: AbortSignal.timeout(3000),
+        });
+        const data = await res.json();
+        const latest = data.version;
+        return {
+            info: { current: currentVersion, latest, isOutdated: latest !== currentVersion },
+            cacheChanged: true,
+        };
     }
     catch {
-        registry = { version: 1, projects: [] };
+        return { info: null, cacheChanged: false };
     }
-    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,
+}
+/**
+ * Context-aware hub menu — the main entry point for `orbital` (no args).
+ * Checks for updates, offers template sync, shows iTerm2 recommendation, then menu.
+ */
+export async function runHub(opts) {
+    const result = { action: 'launch' };
+    p.intro(`${pc.bgCyan(pc.black(' Orbital Command '))} ${pc.dim(`v${opts.packageVersion}`)}`);
+    // ── Update check ──
+    const updateCheck = await checkForUpdate(opts.packageVersion, {
+        lastUpdateCheck: opts.lastUpdateCheck,
+        latestVersion: opts.latestVersion,
+    });
+    if (updateCheck.cacheChanged) {
+        result.updateCache = {
+            lastUpdateCheck: new Date().toISOString(),
+            latestVersion: updateCheck.info?.latest,
+        };
+    }
+    if (updateCheck.info?.isOutdated) {
+        p.log.info(`Update available: ${pc.dim(`v${updateCheck.info.current}`)} → ${pc.cyan(`v${updateCheck.info.latest}`)}`);
+        const updateChoice = await p.select({
+            message: 'Update Orbital Command now?',
+            options: [
+                { value: 'update', label: 'Yes, update' },
+                { value: 'skip', label: 'Skip for now' },
+            ],
+        });
+        if (!p.isCancel(updateChoice) && updateChoice === 'update') {
+            const s = p.spinner();
+            s.start('Updating Orbital Command...');
+            try {
+                execFileSync('npm', ['update', '-g', 'orbital-command'], { stdio: 'pipe', timeout: 60000 });
+                s.stop(`Updated to v${updateCheck.info.latest}!`);
+                p.outro(`Run ${pc.cyan('orbital')} again to use the new version.`);
+                process.exit(0);
+            }
+            catch (err) {
+                s.stop('Update failed.');
+                const msg = err instanceof Error ? err.message : String(err);
+                if (msg.includes('EACCES') || msg.includes('permission denied')) {
+                    p.log.error('Permission denied. Try running with sudo or ensure npm is installed via nvm.');
+                }
+                else if (msg.includes('ETIMEDOUT') || msg.includes('timeout')) {
+                    p.log.error('Update timed out. Check your network connection and try again.');
+                }
+                else {
+                    p.log.error(msg);
+                }
+            }
+        }
+    }
+    // ── Template staleness check ──
+    if (opts.projectPaths.length > 0) {
+        const mod = await import('../manifest.js');
+        const initMod = await import('../init.js');
+        const outdatedProjects = [];
+        for (const proj of opts.projectPaths) {
+            if (!fs.existsSync(proj.path)) {
+                p.log.warn(`${proj.name}: project path not found (${proj.path})`);
+                continue;
+            }
+            const manifest = mod.loadManifest(proj.path);
+            if (!manifest)
+                continue;
+            const claudeDir = path.join(proj.path, '.claude');
+            mod.refreshFileStatuses(manifest, claudeDir);
+            const summary = mod.summarizeManifest(manifest);
+            const parts = Object.entries(summary.byType)
+                .filter(([, counts]) => counts.outdated > 0)
+                .map(([type, counts]) => `${counts.outdated} ${type}`);
+            if (parts.length > 0) {
+                outdatedProjects.push({ name: proj.name, path: proj.path, details: parts });
+            }
+        }
+        if (outdatedProjects.length > 0) {
+            const lines = outdatedProjects.map(proj => `  ${pc.cyan(proj.name.padEnd(16))} ${proj.details.join(', ')} outdated`);
+            const count = outdatedProjects.length;
+            p.note(lines.join('\n'), `${count} project${count > 1 ? 's have' : ' has'} outdated templates`);
+            const syncChoice = await p.select({
+                message: 'Update project templates now?',
+                options: [
+                    { value: 'update', label: 'Yes, update all safe files', hint: 'skips modified and pinned' },
+                    { value: 'skip', label: 'Skip for now' },
+                ],
+            });
+            if (!p.isCancel(syncChoice) && syncChoice === 'update') {
+                for (const proj of outdatedProjects) {
+                    const s = p.spinner();
+                    s.start(`Updating ${proj.name}...`);
+                    try {
+                        initMod.runUpdate(proj.path, { dryRun: false });
+                        s.stop(`${proj.name} updated.`);
+                    }
+                    catch (err) {
+                        s.stop(`${proj.name} failed.`);
+                        p.log.warn(err instanceof Error ? err.message : String(err));
+                    }
+                }
+            }
+        }
+    }
+    // ── iTerm2 recommendation (macOS only, one-time) ──
+    if (opts.isMac && !opts.itermPromptShown && !isITerm2Available()) {
+        p.note(`Sprint dispatch, batch orchestration, and session management\n` +
+            `use iTerm2 tabs to run parallel Claude Code sessions.\n` +
+            `Without it, sessions fall back to basic subprocess mode.`, 'iTerm2 Recommended');
+        const itermChoice = await p.select({
+            message: 'Install iTerm2?',
+            options: [
+                { value: 'install', label: 'Open download page', hint: 'https://iterm2.com' },
+                { value: 'skip', label: 'Skip for now' },
+            ],
+        });
+        result.setItermPromptShown = true;
+        if (!p.isCancel(itermChoice) && itermChoice === 'install') {
+            spawn('open', ['https://iterm2.com'], { detached: true, stdio: 'ignore' }).unref();
+            p.log.info('Waiting for iTerm2 to install... (press any key to skip)');
+            await new Promise((resolve) => {
+                let done = false;
+                const cleanup = () => {
+                    if (done)
+                        return;
+                    done = true;
+                    process.stdin.setRawMode?.(false);
+                    process.stdin.removeListener('data', onKey);
+                    process.stdin.pause();
+                    clearInterval(timer);
+                    resolve();
+                };
+                const onKey = () => { cleanup(); };
+                const startTime = Date.now();
+                const MAX_WAIT = 10 * 60 * 1000; // 10 minutes
+                const timer = setInterval(() => {
+                    if (isITerm2Available()) {
+                        p.log.success('iTerm2 detected!');
+                        cleanup();
+                    }
+                    else if (Date.now() - startTime > MAX_WAIT) {
+                        cleanup();
+                    }
+                }, 3000);
+                process.stdin.setRawMode?.(true);
+                process.stdin.resume();
+                process.stdin.on('data', onKey);
+            });
+        }
+    }
+    // ── Build menu options based on project state ──
+    const projectHint = opts.projectNames.length > 0
+        ? pc.dim(` (${opts.projectNames.join(', ')})`)
+        : '';
+    const options = [];
+    if (opts.isProjectInitialized) {
+        options.push({ value: 'launch', label: `Launch dashboard${projectHint}` }, { value: 'config', label: 'Config', hint: 'modify project settings' }, { value: 'doctor', label: 'Doctor', hint: 'health check & diagnostics' }, { value: 'update', label: 'Update templates', hint: 'sync to latest' }, { value: 'status', label: 'Status', hint: 'template sync status' }, { value: 'reset', label: 'Reset to defaults', hint: 'force-reset all templates' });
+    }
+    else {
+        options.push({ value: 'init', label: 'Initialize this project' }, { value: 'launch', label: `Launch dashboard${projectHint}` });
+    }
+    const action = await p.select({
+        message: 'What would you like to do?',
+        options,
     });
-    fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2), 'utf8');
+    if (p.isCancel(action)) {
+        p.cancel('Cancelled.');
+        process.exit(0);
+    }
+    // ── Double-confirm for destructive reset ──
+    if (action === 'reset') {
+        p.note('This will overwrite ALL hooks, skills, agents, and workflow config\n' +
+            'with the default templates. Modified and pinned files will be replaced.\n' +
+            'Your scopes, database, and orbital.config.json are preserved.', 'Warning');
+        const confirmReset = await p.confirm({
+            message: 'Are you sure you want to reset all templates?',
+            initialValue: false,
+        });
+        if (p.isCancel(confirmReset) || !confirmReset) {
+            p.cancel('Reset cancelled.');
+            process.exit(0);
+        }
+        const doubleConfirm = await p.confirm({
+            message: 'This cannot be undone. Continue?',
+            initialValue: false,
+        });
+        if (p.isCancel(doubleConfirm) || !doubleConfirm) {
+            p.cancel('Reset cancelled.');
+            process.exit(0);
+        }
+    }
+    result.action = action;
+    return result;
 }
 // ─── Template Version Stamping ─────────────────────────────────
 function stampTemplateVersion(projectRoot, packageVersion) {
@@ -148,7 +331,9 @@ function stampTemplateVersion(projectRoot, packageVersion) {
         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');
+            const tmp = configPath + `.tmp.${process.pid}`;
+            fs.writeFileSync(tmp, JSON.stringify(config, null, 2) + '\n', 'utf8');
+            fs.renameSync(tmp, configPath);
         }
     }
     catch { /* ignore malformed config */ }

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

@@ -14,8 +14,7 @@ export async function phaseWelcome(state) {
         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: 'configure', label: 'Open config editor', hint: 'modify settings' },
                 { value: 'cancel', label: 'Cancel' },
             ],
         });
@@ -27,8 +26,6 @@ export async function phaseWelcome(state) {
             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/ui.js

@@ -15,14 +15,13 @@ 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')}                 Add a project or launch the dashboard
   ${pc.cyan('orbital doctor')}          Health check & version info`,
-    addProject: `You can add projects now or later with ${pc.cyan('orbital init')}.
+    addProject: `You can add projects now or later by running ${pc.cyan('orbital')} in a project directory.
 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.`,
+You can reconfigure settings or select ${pc.cyan('Reset to defaults')} from the hub menu.`,
     projectConfig: `${pc.bold('Project Config')} ${pc.dim('(.claude/orbital.config.json)')}
 
 Each project gets its own config inside ${pc.cyan('.claude/')}. The project
@@ -45,16 +44,16 @@ ${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
+  1. Run ${pc.cyan('orbital')} and select ${pc.bold('Launch 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')}           Hub menu — launch, config, doctor, etc.
   ${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`,
+  ${pc.cyan('orbital update')}    Sync to latest templates`,
 };
 // ─── Formatting Helpers ─────────────────────────────────────────
 export function formatDetectedCommands(commands) {