orbital-command 1.1.0 → 1.1.1

package/bin/commands/launch.js

@@ -38,7 +38,6 @@ export function cmdLaunchOrDev(forceViteFlag) {
   const env = {
     ...process.env,
     ORBITAL_LAUNCH_MODE: 'central',
-    ORBITAL_AUTO_REGISTER: projectRoot,
     ORBITAL_SERVER_PORT: String(serverPort),
   };
 

package/bin/lib/helpers.js

@@ -39,15 +39,6 @@ export function resolveBin(name) {
   return null;
 }
 
-export function isGitRepo() {
-  try {
-    execFileSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8', stdio: 'pipe' });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 export function detectProjectRoot() {
   try {
     return execFileSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8', stdio: 'pipe' }).trim();
@@ -56,13 +47,6 @@ export function detectProjectRoot() {
   }
 }
 
-export function requireGitRepo() {
-  if (!isGitRepo()) {
-    console.error('Not a git repository. Run `orbital` from inside a project directory.');
-    process.exit(1);
-  }
-}
-
 export function loadConfig(projectRoot) {
   const configPath = path.join(projectRoot, '.claude', 'orbital.config.json');
   if (fs.existsSync(configPath)) {
@@ -84,21 +68,6 @@ export function getPackageVersion() {
   }
 }
 
-export function stampTemplateVersion(projectRoot) {
-  const configPath = path.join(projectRoot, '.claude', 'orbital.config.json');
-  if (!fs.existsSync(configPath)) return;
-
-  try {
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-    const version = getPackageVersion();
-    if (config.templateVersion !== version) {
-      config.templateVersion = version;
-      fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
-      console.log(`  Stamped  templateVersion: ${version}`);
-    }
-  } catch { /* ignore malformed config */ }
-}
-
 export function openBrowser(url) {
   const platform = process.platform;
   if (platform === 'darwin') {
@@ -188,6 +157,7 @@ Usage:
   orbital <command>      Run a specific command directly
 
 Commands:
+  launch            Launch the dashboard directly
   config            Modify project settings interactively
   doctor            Health check and version diagnostics
   update            Sync templates and apply migrations

package/bin/orbital.js

@@ -10,7 +10,6 @@ import {
   loadSharedModule,
   loadWizardModule,
   orbitalSetupDone,
-  stampTemplateVersion,
   printHelp,
 } from './lib/helpers.js';
 
@@ -34,9 +33,10 @@ async function runHubFlow() {
   const wiz = await loadWizardModule();
   const hubVersion = getPackageVersion();
 
-  // First-time global setup — no menu, just run the wizard
+  // First-time global setup — run wizard then launch dashboard
   if (!orbitalSetupDone()) {
     await wiz.runSetupWizard(hubVersion);
+    cmdLaunchOrDev(false);
     return;
   }
 
@@ -45,23 +45,22 @@ async function runHubFlow() {
     path.join(hubRoot, '.claude', 'orbital.config.json')
   );
   const hubRegistry = loadRegistry();
-  const projectNames = (hubRegistry.projects || []).map(p => p.name);
 
-  // No registered projects — launch dashboard directly.
+  // Not an initialized project — launch dashboard directly.
   // The frontend Add Project modal handles project setup.
-  if (!isInitialized && projectNames.length === 0) {
+  if (!isInitialized) {
     cmdLaunchOrDev(false);
     return;
   }
 
-  // Show hub menu (initialized OR has registered projects)
+  // Show hub menu for initialized projects
+  const projectNames = (hubRegistry.projects || []).map(p => p.name);
   const projects = (hubRegistry.projects || [])
     .filter(p => p.enabled !== false)
     .map(p => ({ name: p.name, path: p.path }));
 
   const hubResult = await wiz.runHub({
     packageVersion: hubVersion,
-    isProjectInitialized: isInitialized,
     projectNames,
     itermPromptShown: hubRegistry.itermPromptShown === true,
     isMac: process.platform === 'darwin',
@@ -85,26 +84,29 @@ async function runHubFlow() {
     writeRegistryAtomic(hubRegistry);
   }
 
-  // Route the chosen action
-  switch (hubResult.action) {
-    case 'launch': cmdLaunchOrDev(false); break;
-    case 'init':
-      await wiz.runProjectSetup(hubRoot, hubVersion, []);
-      stampTemplateVersion(hubRoot);
-      break;
-    case 'config': await cmdConfig([]); break;
-    case 'doctor': await cmdDoctor(); break;
-    case 'update': await cmdUpdate([]); break;
-    case 'status': await cmdStatus(); break;
-    case 'reset': {
-      const { runInit } = await loadSharedModule();
-      runInit(hubRoot, { force: true });
-      stampTemplateVersion(hubRoot);
-      break;
+  // Route the chosen action, then loop back to menu
+  let action = hubResult.action;
+
+  while (true) {
+    switch (action) {
+      case 'launch': cmdLaunchOrDev(false); return;
+      case 'config': await cmdConfig([]); break;
+      case 'doctor': await cmdDoctor(); break;
+      case 'update': await cmdUpdate([]); break;
+      case 'status': await cmdStatus(); break;
+      case 'reset': {
+        const { runInit } = await loadSharedModule();
+        runInit(hubRoot, { force: true });
+        break;
+      }
+      default:
+        console.error(`Unknown action: ${action}`);
+        process.exit(1);
     }
-    default:
-      console.error(`Unknown action: ${hubResult.action}`);
-      process.exit(1);
+
+    // Show menu again after completing an action
+    console.log('');
+    action = await wiz.promptHubAction(projectNames);
   }
 }
 
@@ -116,14 +118,14 @@ const [command, ...args] = process.argv.slice(2);
 
 async function main() {
   switch (command) {
-    // Deprecated commands — silently redirect to hub
-    case 'init':
-    case 'setup':
-    case 'launch':
     case undefined:
       await runHubFlow();
       break;
 
+    case 'launch':
+      cmdLaunchOrDev(false);
+      break;
+
     // Active commands
     case 'config':
       await cmdConfig(args);

package/dist/server/server/index.js

@@ -13,7 +13,7 @@ import { SyncService } from './services/sync-service.js';
 import { startGlobalWatcher } from './watchers/global-watcher.js';
 import { createSyncRoutes } from './routes/sync-routes.js';
 import { seedGlobalPrimitives } from './init.js';
-import { ensureOrbitalHome, loadGlobalConfig, registerProject as registerProjectGlobal, GLOBAL_PRIMITIVES_DIR, ORBITAL_HOME, } from './global-config.js';
+import { ensureOrbitalHome, GLOBAL_PRIMITIVES_DIR, ORBITAL_HOME, } from './global-config.js';
 export async function startCentralServer(overrides) {
     ensureOrbitalHome();
     const envLevel = process.env.ORBITAL_LOG_LEVEL;
@@ -23,12 +23,6 @@ export async function startCentralServer(overrides) {
     const log = createLogger('central');
     const port = overrides?.port ?? (Number(process.env.ORBITAL_SERVER_PORT) || 4444);
     const clientPort = overrides?.clientPort ?? (Number(process.env.ORBITAL_CLIENT_PORT) || 4445);
-    // Auto-register current project if registry is empty
-    const globalConfig = loadGlobalConfig();
-    if (globalConfig.projects.length === 0 && overrides?.autoRegisterPath) {
-        registerProjectGlobal(overrides.autoRegisterPath);
-        log.info('Auto-registered current project', { path: overrides.autoRegisterPath });
-    }
     const app = express();
     const httpServer = createServer(app);
     const io = new Server(httpServer, {
@@ -201,10 +195,8 @@ const isDirectRun = process.argv[1] && (process.argv[1].endsWith('server/index.t
     process.argv[1].endsWith('server/index.js') ||
     process.argv[1].endsWith('server'));
 if (isDirectRun) {
-    const projectRoot = process.env.ORBITAL_PROJECT_ROOT || process.cwd();
     startCentralServer({
         port: Number(process.env.ORBITAL_SERVER_PORT) || 4444,
-        autoRegisterPath: projectRoot,
     }).then(({ shutdown }) => {
         process.on('SIGINT', async () => {
             await shutdown();

package/dist/server/server/launch.js

@@ -3,17 +3,14 @@
  *
  * Reads environment variables set by bin/orbital.js:
  *   ORBITAL_LAUNCH_MODE=central
- *   ORBITAL_AUTO_REGISTER=<path>  (if no projects registered yet)
  *   ORBITAL_SERVER_PORT=<port>
  */
 import { startCentralServer } from './index.js';
 import { createLogger } from './utils/logger.js';
 const log = createLogger('launch');
 const port = Number(process.env.ORBITAL_SERVER_PORT) || 4444;
-const autoRegisterPath = process.env.ORBITAL_AUTO_REGISTER || undefined;
 startCentralServer({
     port,
-    autoRegisterPath: autoRegisterPath || undefined,
 }).then(({ shutdown }) => {
     process.on('SIGINT', async () => {
         await shutdown();

package/dist/server/server/routes/sync-routes.js

@@ -3,7 +3,7 @@ import fs from 'fs';
 import path from 'path';
 import { execFile } from 'child_process';
 import { isValidRelativePath } from '../utils/route-helpers.js';
-import { runInit } from '../init.js';
+import { runInit, TEMPLATES_DIR } from '../init.js';
 import { loadGlobalConfig } from '../global-config.js';
 import { getPackageVersion } from '../utils/package-info.js';
 export function createSyncRoutes({ syncService, projectManager }) {
@@ -253,7 +253,7 @@ export function createSyncRoutes({ syncService, projectManager }) {
 // ─── Helpers ──────────────────────────────────────────────
 function seedWelcomeCard(projectRoot, preset) {
     // Determine the planning directory from the preset
-    const presetsDir = path.join(path.dirname(path.dirname(new URL(import.meta.url).pathname)), 'templates', 'presets');
+    const presetsDir = path.join(TEMPLATES_DIR, 'presets');
     let planningDir = 'planning'; // default fallback
     try {
         const presetPath = path.join(presetsDir, `${preset}.json`);

package/dist/server/server/services/telemetry-service.js

@@ -0,0 +1,143 @@
+/**
+ * Session Telemetry — uploads raw Claude session JSONL files to a remote
+ * Cloudflare Worker + R2 endpoint. This entire feature lives in this single
+ * file for easy removal.
+ */
+import fs from 'fs';
+import path from 'path';
+import { Router } from 'express';
+import { getClaudeSessionsDir } from '../config.js';
+// ─── Service ───────────────────────────────────────────────
+export class TelemetryService {
+    db;
+    config;
+    projectName;
+    projectRoot;
+    lastResult = null;
+    constructor(db, config, projectName, projectRoot) {
+        this.db = db;
+        this.config = config;
+        this.projectName = projectName;
+        this.projectRoot = projectRoot;
+    }
+    get enabled() {
+        return this.config.enabled && this.config.url.length > 0;
+    }
+    /** Upload sessions that have changed since last telemetry send. */
+    async uploadChangedSessions() {
+        if (!this.enabled)
+            return { ok: true, uploaded: 0, errors: 0 };
+        const rows = this.db.prepare(`SELECT id, claude_session_id, ended_at, telemetry_sent_at
+       FROM sessions
+       WHERE claude_session_id IS NOT NULL
+         AND (telemetry_sent_at IS NULL OR ended_at > telemetry_sent_at)`).all();
+        return this.uploadRows(rows);
+    }
+    /** Force re-upload all sessions regardless of telemetry_sent_at. */
+    async uploadAllSessions() {
+        if (!this.enabled)
+            return { ok: true, uploaded: 0, errors: 0 };
+        const rows = this.db.prepare(`SELECT id, claude_session_id, ended_at, telemetry_sent_at
+       FROM sessions
+       WHERE claude_session_id IS NOT NULL`).all();
+        return this.uploadRows(rows);
+    }
+    /** Ping the remote health endpoint. */
+    async testConnection() {
+        try {
+            const res = await fetch(`${this.config.url}/health`, {
+                method: 'GET',
+                headers: this.config.headers,
+                signal: AbortSignal.timeout(10_000),
+            });
+            const body = await res.text();
+            return { ok: res.ok, status: res.status, body };
+        }
+        catch (err) {
+            return { ok: false, status: 0, body: err.message };
+        }
+    }
+    getStatus() {
+        return {
+            enabled: this.enabled,
+            url: this.config.url || null,
+            lastResult: this.lastResult,
+        };
+    }
+    // ─── Internal ──────────────────────────────────────────────
+    async uploadRows(rows) {
+        if (rows.length === 0) {
+            this.lastResult = { ok: true, uploaded: 0, errors: 0 };
+            return this.lastResult;
+        }
+        const sessionsDir = getClaudeSessionsDir(this.projectRoot);
+        const now = new Date().toISOString();
+        let uploaded = 0;
+        let errors = 0;
+        const updateStmt = this.db.prepare('UPDATE sessions SET telemetry_sent_at = ? WHERE id = ?');
+        // Deduplicate by claude_session_id (multiple rows can share the same JSONL file)
+        const seen = new Set();
+        const unique = [];
+        for (const row of rows) {
+            if (row.claude_session_id && !seen.has(row.claude_session_id)) {
+                seen.add(row.claude_session_id);
+                unique.push(row);
+            }
+        }
+        for (const row of unique) {
+            const sessionId = row.claude_session_id;
+            const filePath = path.join(sessionsDir, `${sessionId}.jsonl`);
+            if (!fs.existsSync(filePath)) {
+                continue;
+            }
+            try {
+                const body = fs.readFileSync(filePath);
+                const encodedProject = encodeURIComponent(this.projectName);
+                const url = `${this.config.url}/upload/${encodedProject}/${sessionId}.jsonl`;
+                const res = await fetch(url, {
+                    method: 'PUT',
+                    body,
+                    headers: {
+                        'Content-Type': 'application/x-ndjson',
+                        ...this.config.headers,
+                    },
+                    signal: AbortSignal.timeout(30_000),
+                });
+                if (res.ok) {
+                    uploaded++;
+                    // Update telemetry_sent_at for ALL rows with this claude_session_id
+                    const matching = rows.filter((r) => r.claude_session_id === sessionId);
+                    for (const m of matching) {
+                        updateStmt.run(now, m.id);
+                    }
+                }
+                else {
+                    errors++;
+                }
+            }
+            catch {
+                errors++;
+            }
+        }
+        this.lastResult = { ok: errors === 0, uploaded, errors };
+        return this.lastResult;
+    }
+}
+export function createTelemetryRoutes({ telemetryService }) {
+    const router = Router();
+    router.post('/telemetry/trigger', async (req, res) => {
+        const force = req.query.force === 'true';
+        const result = force
+            ? await telemetryService.uploadAllSessions()
+            : await telemetryService.uploadChangedSessions();
+        res.json(result);
+    });
+    router.post('/telemetry/test', async (_req, res) => {
+        const result = await telemetryService.testConnection();
+        res.json(result);
+    });
+    router.get('/telemetry/status', (_req, res) => {
+        res.json(telemetryService.getStatus());
+    });
+    return router;
+}

package/dist/server/server/wizard/detect.js

@@ -5,9 +5,6 @@ import fs from 'fs';
 import path from 'path';
 const ORBITAL_HOME = path.join(process.env.HOME || process.env.USERPROFILE || '~', '.orbital');
 export { ORBITAL_HOME };
-export function isInteractiveTerminal() {
-    return !!(process.stdout.isTTY && !process.env.CI);
-}
 export function isOrbitalSetupDone() {
     return fs.existsSync(path.join(ORBITAL_HOME, 'config.json'));
 }
@@ -18,79 +15,3 @@ export function buildSetupState(packageVersion) {
         linkedProjects: [],
     };
 }
-export function buildProjectState(projectRoot, packageVersion) {
-    const projectConfigExists = fs.existsSync(path.join(projectRoot, '.claude', 'orbital.config.json'));
-    return {
-        projectRoot,
-        isProjectInitialized: projectConfigExists,
-        packageVersion,
-    };
-}
-export function detectProjectName(projectRoot) {
-    return path.basename(projectRoot)
-        .replace(/[-_]+/g, ' ')
-        .replace(/\b\w/g, c => c.toUpperCase());
-}
-export function detectCommands(projectRoot) {
-    const commands = {
-        typeCheck: null,
-        lint: null,
-        build: null,
-        test: null,
-    };
-    const pkgJsonPath = path.join(projectRoot, 'package.json');
-    if (!fs.existsSync(pkgJsonPath))
-        return commands;
-    try {
-        const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
-        const scripts = pkg.scripts || {};
-        if (scripts.typecheck || scripts['type-check']) {
-            commands.typeCheck = `npm run ${scripts.typecheck ? 'typecheck' : 'type-check'}`;
-        }
-        if (scripts.lint)
-            commands.lint = 'npm run lint';
-        if (scripts.build)
-            commands.build = 'npm run build';
-        if (scripts.test)
-            commands.test = 'npm run test';
-    }
-    catch { /* ignore malformed package.json */ }
-    return commands;
-}
-export function detectPortConflict(serverPort) {
-    const registryPath = path.join(ORBITAL_HOME, 'config.json');
-    if (!fs.existsSync(registryPath))
-        return null;
-    try {
-        const registry = JSON.parse(fs.readFileSync(registryPath, 'utf8'));
-        for (const project of registry.projects || []) {
-            const configPath = path.join(project.path, '.claude', 'orbital.config.json');
-            if (!fs.existsSync(configPath))
-                continue;
-            try {
-                const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-                if (config.serverPort === serverPort)
-                    return project.name;
-            }
-            catch { /* skip unreadable configs */ }
-        }
-    }
-    catch { /* skip unreadable registry */ }
-    return null;
-}
-export function isValidProjectPath(p) {
-    const resolved = p.startsWith('~')
-        ? path.join(process.env.HOME || process.env.USERPROFILE || '~', p.slice(1))
-        : path.resolve(p);
-    if (!fs.existsSync(resolved))
-        return 'Directory does not exist';
-    if (!fs.statSync(resolved).isDirectory())
-        return 'Not a directory';
-    return undefined;
-}
-export function resolveProjectPath(p) {
-    if (p.startsWith('~')) {
-        return path.join(process.env.HOME || process.env.USERPROFILE || '~', p.slice(1));
-    }
-    return path.resolve(p);
-}

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

@@ -2,8 +2,8 @@
  * Interactive CLI wizard — main orchestrator.
  *
  * Entry points:
- *   runSetupWizard()   — Phase 1: first-time Orbital setup (~/.orbital/)
- *   runProjectSetup()  — Phase 2: per-project scaffolding (.claude/)
+ *   runSetupWizard()   — First-time Orbital setup (~/.orbital/)
+ *   runHub()           — Context-aware hub menu (orbital)
  *   runConfigEditor()  — interactive config editor (orbital config)
  *   runDoctor()        — health diagnostics (orbital doctor)
  */
@@ -12,16 +12,11 @@ import path from 'path';
 import { spawn, execFileSync } from 'child_process';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
-import { buildSetupState, buildProjectState } from './detect.js';
+import { buildSetupState } 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 { 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 ─────────────────────────────────────
 /**
@@ -32,56 +27,7 @@ export async function runSetupWizard(packageVersion) {
     const state = buildSetupState(packageVersion);
     p.intro(`${pc.bgCyan(pc.black(' Orbital Command '))} ${pc.dim(`v${packageVersion}`)}`);
     await phaseSetupWizard(state);
-    p.outro(`Run ${pc.cyan('orbital')} to launch the dashboard and add your first project.`);
-}
-// ─── 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')} to launch 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, { name: 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);
+    p.outro('Launching dashboard...');
 }
 /** Returns true if `a` is older than `b` (semver comparison). */
 function isOlderThan(a, b) {
@@ -272,17 +218,26 @@ export async function runHub(opts) {
             });
         }
     }
-    // ── Build menu options based on project state ──
-    const projectHint = opts.projectNames.length > 0
-        ? pc.dim(` (${opts.projectNames.join(', ')})`)
+    // ── Show menu and pick action ──
+    result.action = await promptHubAction(opts.projectNames);
+    return result;
+}
+/**
+ * Show the hub menu and return the chosen action.
+ * Exported separately so the CLI can loop back after executing an action.
+ */
+export async function promptHubAction(projectNames) {
+    const projectHint = projectNames.length > 0
+        ? pc.dim(` (${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 options = [
+        { 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' },
+    ];
     const action = await p.select({
         message: 'What would you like to do?',
         options,
@@ -291,7 +246,7 @@ export async function runHub(opts) {
         p.cancel('Cancelled.');
         process.exit(0);
     }
-    // ── Double-confirm for destructive reset ──
+    // 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' +
@@ -301,34 +256,15 @@ export async function runHub(opts) {
             initialValue: false,
         });
         if (p.isCancel(confirmReset) || !confirmReset) {
-            p.cancel('Reset cancelled.');
-            process.exit(0);
+            return promptHubAction(projectNames);
         }
         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) {
-    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;
-            const tmp = configPath + `.tmp.${process.pid}`;
-            fs.writeFileSync(tmp, JSON.stringify(config, null, 2) + '\n', 'utf8');
-            fs.renameSync(tmp, configPath);
+            return promptHubAction(projectNames);
         }
     }
-    catch { /* ignore malformed config */ }
+    return action;
 }

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

@@ -1,8 +1,7 @@
 /**
  * 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/
+ * Phase 1 (SetupState) — first-time Orbital setup, ~/.orbital/ creation.
+ * Project setup is handled by the frontend Add Project modal.
  */
 export { WORKFLOW_PRESETS } from '../../shared/workflow-presets.js';