orbital-command 0.2.0 → 0.3.0

package/server/wizard/phases/project-setup.ts

@@ -0,0 +1,106 @@
+/**
+ * Phase 1: Project configuration — name, commands, ports.
+ */
+
+import * as p from '@clack/prompts';
+import type { ProjectSetupState } from '../types.js';
+import { NOTES, formatDetectedCommands } from '../ui.js';
+import { detectProjectName, detectCommands, detectPortConflict } from '../detect.js';
+
+export async function phaseProjectSetup(state: ProjectSetupState): Promise<void> {
+  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: Record<string, string | null>): Promise<Record<string, string | null>> {
+  const commands: Record<string, string | null> = {};
+  const labels: Record<string, string> = {
+    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/server/wizard/phases/setup-wizard.ts

@@ -0,0 +1,78 @@
+/**
+ * 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 type { SetupState } from '../types.js';
+import { NOTES } from '../ui.js';
+import { isValidProjectPath, resolveProjectPath, ORBITAL_HOME } from '../detect.js';
+
+export async function phaseSetupWizard(state: SetupState): Promise<void> {
+  // 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/server/wizard/phases/welcome.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 type { ProjectSetupState } from '../types.js';
+import { NOTES } from '../ui.js';
+import { runConfigEditor } from '../config-editor.js';
+
+export async function phaseWelcome(state: ProjectSetupState): Promise<boolean> {
+  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/server/wizard/phases/workflow-setup.ts

@@ -0,0 +1,28 @@
+/**
+ * Phase 2: Workflow preset selection.
+ */
+
+import * as p from '@clack/prompts';
+import type { ProjectSetupState } from '../types.js';
+import { WORKFLOW_PRESETS } from '../types.js';
+import { NOTES } from '../ui.js';
+
+export async function phaseWorkflowSetup(state: ProjectSetupState): Promise<void> {
+  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 as string;
+}

package/server/wizard/types.ts

@@ -0,0 +1,56 @@
+/**
+ * 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 interface SetupState {
+  packageVersion: string;
+  isFirstTime: boolean;           // ~/.orbital/ doesn't exist yet
+  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 interface PresetInfo {
+  value: string;
+  label: string;
+  hint: string;
+}
+
+export const WORKFLOW_PRESETS: PresetInfo[] = [
+  {
+    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/server/wizard/ui.ts

@@ -0,0 +1,93 @@
+/**
+ * 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: { hooks: number; skills: number; agents: number }) =>
+    `${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: Record<string, string | null>): string {
+  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: {
+  projectName?: string;
+  workflowPreset?: string;
+  serverPort?: number;
+  clientPort?: number;
+}): string {
+  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');
+}

package/shared/__fixtures__/workflow-configs.ts

@@ -0,0 +1,80 @@
+import type { WorkflowConfig } from '../workflow-config.js';
+import defaultWorkflowJson from '../default-workflow.json' with { type: 'json' };
+
+/** The full 7-list trunk-based workflow from default-workflow.json */
+export const DEFAULT_CONFIG = defaultWorkflowJson as unknown as WorkflowConfig;
+
+/** Smallest valid config: 2 lists, 1 edge, 1 entry point */
+export const MINIMAL_CONFIG: WorkflowConfig = {
+  version: 1,
+  name: 'Minimal',
+  lists: [
+    { id: 'todo', label: 'To Do', order: 0, color: '0 0% 50%', hex: '#808080', isEntryPoint: true, hasDirectory: true },
+    { id: 'done', label: 'Done', order: 1, color: '120 50% 50%', hex: '#40bf40', hasDirectory: true },
+  ],
+  edges: [
+    { from: 'todo', to: 'done', direction: 'forward', command: null, confirmLevel: 'quick', label: 'Complete', description: 'Mark as done' },
+  ],
+  terminalStatuses: ['done'],
+  allowedCommandPrefixes: ['/test-'],
+};
+
+/** Config with hooks for hook-related tests */
+export const CONFIG_WITH_HOOKS: WorkflowConfig = {
+  version: 1,
+  name: 'With Hooks',
+  lists: [
+    { id: 'backlog', label: 'Backlog', order: 0, color: '0 0% 50%', hex: '#808080', isEntryPoint: true, hasDirectory: true, supportsSprint: true },
+    { id: 'active', label: 'Active', order: 1, color: '200 80% 50%', hex: '#1a8ccc', hasDirectory: true, sessionKey: 'implementScope' },
+    { id: 'review', label: 'Review', order: 2, color: '45 90% 50%', hex: '#f0c010', hasDirectory: true, supportsBatch: true, sessionKey: 'reviewGate' },
+    { id: 'shipped', label: 'Shipped', order: 3, color: '120 70% 40%', hex: '#30a030', hasDirectory: true, gitBranch: 'main' },
+  ],
+  edges: [
+    { from: 'backlog', to: 'active', direction: 'forward', command: '/scope-implement {id}', confirmLevel: 'quick', label: 'Start', description: 'Begin work', dispatchOnly: true, autoRevert: true, hooks: ['blocker-check'], agents: ['architect'] },
+    { from: 'active', to: 'review', direction: 'forward', command: '/scope-post-review {id}', confirmLevel: 'quick', label: 'Review', description: 'Submit for review', dispatchOnly: true, hooks: ['blocker-check', 'session-enforcer'] },
+    { from: 'review', to: 'shipped', direction: 'forward', command: '/git-main', confirmLevel: 'quick', label: 'Ship', description: 'Push to main', dispatchOnly: true },
+    { from: 'active', to: 'backlog', direction: 'backward', command: null, confirmLevel: 'quick', label: 'Revert', description: 'Back to backlog', humanOnly: true },
+    { from: 'review', to: 'active', direction: 'backward', command: null, confirmLevel: 'quick', label: 'Rework', description: 'Back to active' },
+  ],
+  hooks: [
+    { id: 'blocker-check', label: 'Blocker Check', timing: 'before', type: 'shell', target: '.claude/hooks/blocker-check.sh', blocking: false, category: 'gate', description: 'Checks for blockers' },
+    { id: 'session-enforcer', label: 'Session Auth', timing: 'before', type: 'shell', target: '.claude/hooks/session-enforcer.sh', blocking: true, category: 'guard', description: 'Enforces session auth' },
+    { id: 'scope-transition', label: 'File Mover', timing: 'before', type: 'shell', target: '.claude/hooks/scope-transition.sh', blocking: false, category: 'lifecycle' },
+    { id: 'dashboard-sync', label: 'Dashboard Sync', timing: 'after', type: 'shell', target: '.claude/hooks/dashboard-sync.sh', blocking: false, category: 'observer' },
+  ],
+  groups: [
+    { id: 'planning', label: 'Planning', order: 0 },
+    { id: 'development', label: 'Development', order: 1 },
+  ],
+  eventInference: [
+    { eventType: 'SCOPE_STATUS_CHANGED', targetStatus: '', dataField: 'to', forwardOnly: true },
+    { eventType: 'AGENT_STARTED', targetStatus: 'active', forwardOnly: true },
+    { eventType: 'AGENT_COMPLETED', targetStatus: '', conditions: { outcome: ['success', 'failure'], dispatchResolution: true }, forwardOnly: false },
+  ],
+  terminalStatuses: ['shipped'],
+  allowedCommandPrefixes: ['/scope-', '/git-'],
+};
+
+/** Named invalid configs for constructor error tests */
+export const INVALID_CONFIGS = {
+  noLists: { version: 1 as const, name: 'No Lists', lists: [], edges: [{ from: 'a', to: 'b', direction: 'forward' as const, command: null, confirmLevel: 'quick' as const, label: 'X', description: 'X' }] } as WorkflowConfig,
+  noEdges: { version: 1 as const, name: 'No Edges', lists: [{ id: 'a', label: 'A', order: 0, color: '0 0% 0%', hex: '#000', isEntryPoint: true, hasDirectory: true }], edges: [] } as WorkflowConfig,
+  twoEntryPoints: {
+    version: 1 as const,
+    name: 'Two Entry Points',
+    lists: [
+      { id: 'a', label: 'A', order: 0, color: '0 0% 0%', hex: '#000', isEntryPoint: true, hasDirectory: true },
+      { id: 'b', label: 'B', order: 1, color: '0 0% 0%', hex: '#000', isEntryPoint: true, hasDirectory: true },
+    ],
+    edges: [{ from: 'a', to: 'b', direction: 'forward' as const, command: null, confirmLevel: 'quick' as const, label: 'X', description: 'X' }],
+  } as WorkflowConfig,
+  zeroEntryPoints: {
+    version: 1 as const,
+    name: 'Zero Entry Points',
+    lists: [
+      { id: 'a', label: 'A', order: 0, color: '0 0% 0%', hex: '#000', hasDirectory: true },
+      { id: 'b', label: 'B', order: 1, color: '0 0% 0%', hex: '#000', hasDirectory: true },
+    ],
+    edges: [{ from: 'a', to: 'b', direction: 'forward' as const, command: null, confirmLevel: 'quick' as const, label: 'X', description: 'X' }],
+  } as WorkflowConfig,
+};

package/shared/default-workflow.json

@@ -100,6 +100,7 @@
       "label": "Team Review",
       "description": "Runs full agent team review, locks spec, moves to backlog.",
       "dispatchOnly": true,
+      "autoRevert": true,
       "hooks": ["session-enforcer", "blocker-check", "dependency-check", "scope-transition", "orbital-scope-update"]
     },
     {
@@ -128,6 +129,7 @@
       "label": "Start Implementing",
       "description": "Opens a Claude session running /scope-implement.",
       "dispatchOnly": true,
+      "autoRevert": true,
       "hooks": ["session-enforcer", "blocker-check", "dependency-check", "scope-transition", "orbital-scope-update"]
     },
     {
@@ -139,6 +141,7 @@
       "label": "Launch Post-Review",
       "description": "Runs quality gates, formal verification, and code review.",
       "dispatchOnly": true,
+      "autoRevert": true,
       "hooks": ["session-enforcer", "review-gate-check", "blocker-check", "dependency-check", "scope-transition", "orbital-scope-update"]
     },
     {
@@ -179,6 +182,7 @@
       "label": "Commit",
       "description": "Commits scope work.",
       "dispatchOnly": true,
+      "autoRevert": true,
       "hooks": ["session-enforcer", "completion-checklist", "blocker-check", "dependency-check", "scope-transition", "orbital-scope-update", "scope-commit-logger"]
     },
     {
@@ -190,6 +194,7 @@
       "label": "Push to Main",
       "description": "Pushes or PRs scope work to the main branch.",
       "dispatchOnly": true,
+      "autoRevert": true,
       "hooks": ["session-enforcer", "blocker-check", "dependency-check", "scope-transition", "orbital-scope-update", "scope-commit-logger"]
     },
     {
@@ -248,6 +253,66 @@
       "dispatchOnly": false,
       "humanOnly": true,
       "hooks": ["session-enforcer", "scope-transition", "orbital-scope-update"]
+    },
+    {
+      "from": "backlog",
+      "to": "icebox",
+      "direction": "backward",
+      "command": null,
+      "confirmLevel": "quick",
+      "label": "Shelve to Icebox",
+      "description": "Shelves this scope back to the icebox for later consideration.",
+      "dispatchOnly": false,
+      "humanOnly": true,
+      "hooks": ["session-enforcer", "scope-transition", "orbital-scope-update"]
+    },
+    {
+      "from": "implementing",
+      "to": "icebox",
+      "direction": "backward",
+      "command": null,
+      "confirmLevel": "full",
+      "checklist": [
+        "No uncommitted work will be lost",
+        "This scope is being abandoned, not paused"
+      ],
+      "label": "Shelve to Icebox",
+      "description": "Abandons implementation and shelves this scope back to the icebox.",
+      "dispatchOnly": false,
+      "humanOnly": true,
+      "hooks": ["session-enforcer", "scope-transition", "orbital-scope-update"]
+    },
+    {
+      "from": "review",
+      "to": "icebox",
+      "direction": "backward",
+      "command": null,
+      "confirmLevel": "full",
+      "checklist": [
+        "No uncommitted work will be lost",
+        "This scope is being abandoned, not paused"
+      ],
+      "label": "Shelve to Icebox",
+      "description": "Abandons review and shelves this scope back to the icebox.",
+      "dispatchOnly": false,
+      "humanOnly": true,
+      "hooks": ["session-enforcer", "scope-transition", "orbital-scope-update"]
+    },
+    {
+      "from": "completed",
+      "to": "icebox",
+      "direction": "backward",
+      "command": null,
+      "confirmLevel": "full",
+      "checklist": [
+        "Committed work has been reverted or is acceptable to leave",
+        "This scope is being abandoned, not paused"
+      ],
+      "label": "Shelve to Icebox",
+      "description": "Shelves this completed scope back to the icebox.",
+      "dispatchOnly": false,
+      "humanOnly": true,
+      "hooks": ["session-enforcer", "scope-transition", "orbital-scope-update"]
     }
   ],
   "hooks": [