orbital-command 1.1.0 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orbital-command",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Orbital Command — mission control dashboard for Claude Code projects",
   "type": "module",
   "license": "MIT",

package/server/index.ts

@@ -20,8 +20,6 @@ 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';
@@ -29,8 +27,6 @@ import {
 export interface CentralServerOverrides {
   port?: number;
   clientPort?: number;
-  /** If set, auto-register this project on first launch */
-  autoRegisterPath?: string;
 }
 
 export interface CentralServerInstance {
@@ -53,13 +49,6 @@ export async function startCentralServer(overrides?: CentralServerOverrides): Pr
   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);
 
@@ -261,10 +250,8 @@ const isDirectRun = process.argv[1] && (
 );
 
 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/server/launch.ts

@@ -3,7 +3,6 @@
  *
  * 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';
@@ -12,11 +11,9 @@ 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/server/routes/sync-routes.ts

@@ -5,7 +5,7 @@ import { execFile } from 'child_process';
 import type { SyncService } from '../services/sync-service.js';
 import type { ProjectManager } from '../project-manager.js';
 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';
 
@@ -322,7 +322,7 @@ export function createSyncRoutes({ syncService, projectManager }: SyncRouteDeps)
 
 function seedWelcomeCard(projectRoot: string, preset: string): void {
   // 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 {

package/server/wizard/detect.ts

@@ -4,16 +4,12 @@
 
 import fs from 'fs';
 import path from 'path';
-import type { SetupState, ProjectSetupState } from './types.js';
+import type { SetupState } from './types.js';
 
 const ORBITAL_HOME = path.join(process.env.HOME || process.env.USERPROFILE || '~', '.orbital');
 
 export { ORBITAL_HOME };
 
-export function isInteractiveTerminal(): boolean {
-  return !!(process.stdout.isTTY && !process.env.CI);
-}
-
 export function isOrbitalSetupDone(): boolean {
   return fs.existsSync(path.join(ORBITAL_HOME, 'config.json'));
 }
@@ -26,79 +22,3 @@ export function buildSetupState(packageVersion: string): SetupState {
   };
 }
 
-export function buildProjectState(projectRoot: string, packageVersion: string): ProjectSetupState {
-  const projectConfigExists = fs.existsSync(path.join(projectRoot, '.claude', 'orbital.config.json'));
-
-  return {
-    projectRoot,
-    isProjectInitialized: projectConfigExists,
-    packageVersion,
-  };
-}
-
-export function detectProjectName(projectRoot: string): string {
-  return path.basename(projectRoot)
-    .replace(/[-_]+/g, ' ')
-    .replace(/\b\w/g, c => c.toUpperCase());
-}
-
-export function detectCommands(projectRoot: string): Record<string, string | null> {
-  const commands: Record<string, string | null> = {
-    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: number): string | null {
-  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: string): string | undefined {
-  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: string): string {
-  if (p.startsWith('~')) {
-    return path.join(process.env.HOME || process.env.USERPROFILE || '~', p.slice(1));
-  }
-  return path.resolve(p);
-}

package/server/wizard/index.ts

@@ -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)
  */
@@ -13,16 +13,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 };
 
@@ -39,69 +34,7 @@ export async function runSetupWizard(packageVersion: string): Promise<void> {
 
   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: string, packageVersion: string, args: string[]): Promise<void> {
-  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: ReturnType<typeof buildProjectState>, useForce: boolean): Promise<void> {
-  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...');
 }
 
 // ─── Update Check ─────────────────────────────────────────────
@@ -158,7 +91,7 @@ async function checkForUpdate(
 
 // ─── Hub Menu ─────────────────────────────────────────────────
 
-export type HubAction = 'launch' | 'init' | 'config' | 'doctor' | 'update' | 'status' | 'reset';
+export type HubAction = 'launch' | 'config' | 'doctor' | 'update' | 'status' | 'reset';
 
 export interface HubResult {
   action: HubAction;
@@ -172,7 +105,6 @@ export interface HubResult {
  */
 export async function runHub(opts: {
   packageVersion: string;
-  isProjectInitialized: boolean;
   projectNames: string[];
   itermPromptShown: boolean;
   isMac: boolean;
@@ -343,28 +275,28 @@ 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: string[]): Promise<HubAction> {
+  const projectHint = projectNames.length > 0
+    ? pc.dim(` (${projectNames.join(', ')})`)
     : '';
 
-  const options: Array<{ value: HubAction; label: string; hint?: string }> = [];
-
-  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: Array<{ value: HubAction; label: string; hint?: string }> = [
+    { 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?',
@@ -376,7 +308,7 @@ export async function runHub(opts: {
     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' +
@@ -389,36 +321,17 @@ 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);
+      return promptHubAction(projectNames);
     }
   }
 
-  result.action = action;
-  return result;
+  return action;
 }
 
-// ─── Template Version Stamping ─────────────────────────────────
-
-function stampTemplateVersion(projectRoot: string, packageVersion: string): void {
-  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);
-    }
-  } catch { /* ignore malformed config */ }
-}

package/server/wizard/types.ts

@@ -1,9 +1,8 @@
 /**
  * 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 interface SetupState {
@@ -12,19 +11,5 @@ export interface SetupState {
   linkedProjects: string[];       // project paths added during setup
 }
 
-export interface ProjectSetupState {
-  projectRoot: string;
-  isProjectInitialized: boolean;  // .claude/orbital.config.json exists
-  packageVersion: string;
-
-  // Collected from phases
-  projectName?: string;
-  serverPort?: number;
-  clientPort?: number;
-  detectedCommands?: Record<string, string | null>;
-  selectedCommands?: Record<string, string | null>;
-  workflowPreset?: string;        // 'default' | 'minimal' | 'development' | 'gitflow'
-}
-
 export type { PresetInfo } from '../../shared/workflow-presets.js';
 export { WORKFLOW_PRESETS } from '../../shared/workflow-presets.js';

package/templates/hooks/block-push.sh

@@ -37,8 +37,22 @@ _pipeline_after() {
   echo "$result"
 }
 
+# Check if a flag file's session is still alive; remove stale flags
+_flag_alive() {
+  local flag="$1"
+  [ -f "$flag" ] || return 1
+  local pid
+  pid=$(cat "$flag" 2>/dev/null)
+  # Empty flag (legacy touch-style) or dead process → stale
+  if [ -z "$pid" ] || ! kill -0 "$pid" 2>/dev/null; then
+    rm -f "$flag"
+    return 1
+  fi
+  return 0
+}
+
 # Block git push during /git-commit
-if [ -f "$PUSH_FLAG" ]; then
+if _flag_alive "$PUSH_FLAG"; then
   if echo "$COMMAND" | grep -qE '(^|[;&|]\s*)git\s+push'; then
     "$HOOK_DIR/orbital-emit.sh" VIOLATION '{"rule":"block-push","outcome":"blocked"}' 2>/dev/null || true
     REMAINING=$(_pipeline_after "completed")
@@ -51,7 +65,7 @@ if [ -f "$PUSH_FLAG" ]; then
 fi
 
 # Block git commit/add during /scope-implement
-if [ -f "$IMPL_FLAG" ]; then
+if _flag_alive "$IMPL_FLAG"; then
   if echo "$COMMAND" | grep -qE '(^|[;&|]\s*)git\s+(commit|add)'; then
     "$HOOK_DIR/orbital-emit.sh" VIOLATION '{"rule":"block-commit-implementing","outcome":"blocked"}' 2>/dev/null || true
     REMAINING=$(_pipeline_after "implementing")

package/templates/hooks/git-commit-guard.sh

@@ -18,15 +18,16 @@ PUSH_FLAG="$PROJECT_DIR/.claude/.block-push-active"
 IMPL_FLAG="$PROJECT_DIR/.claude/.implementing-session"
 
 # /git-commit → block pushes during commit skill
+# Store parent PID so block-push.sh can detect stale flags from dead sessions
 if [ "$SKILL" = "git-commit" ]; then
-  touch "$PUSH_FLAG"
+  echo "$PPID" > "$PUSH_FLAG"
 else
   rm -f "$PUSH_FLAG"
 fi
 
 # /scope-implement → block commits during implementing
 if [ "$SKILL" = "scope-implement" ]; then
-  touch "$IMPL_FLAG"
+  echo "$PPID" > "$IMPL_FLAG"
 else
   rm -f "$IMPL_FLAG"
 fi

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

@@ -1,39 +0,0 @@
-/**
- * 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

@@ -1,90 +0,0 @@
-/**
- * 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/welcome.js

@@ -1,32 +0,0 @@
-/**
- * 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: 'configure', label: 'Open config editor', hint: 'modify settings' },
-                { 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);
-        }
-    }
-    // Not initialized — continue normally
-    return false;
-}

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

@@ -1,22 +0,0 @@
-/**
- * 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;
-}