orbital-command 0.3.0 → 1.0.0

package/server/routes/config-routes.ts

@@ -3,7 +3,7 @@ import type { Emitter } from '../project-emitter.js';
 import { ConfigService, isValidPrimitiveType } from '../services/config-service.js';
 import type { ConfigPrimitiveType } from '../services/config-service.js';
 import type { WorkflowService } from '../services/workflow-service.js';
-import { errMsg } from '../utils/route-helpers.js';
+import { catchRoute, inferErrorStatus } from '../utils/route-helpers.js';
 
 interface ConfigRouteDeps {
   projectRoot: string;
@@ -25,21 +25,17 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
   }
 
   // GET /config/:type/tree — directory tree with frontmatter
-  router.get('/config/:type/tree', (req, res) => {
+  router.get('/config/:type/tree', catchRoute((req, res) => {
     const type = parseType(req.params.type, res);
     if (!type) return;
 
-    try {
-      const basePath = configService.getBasePath(type);
-      const tree = configService.scanDirectory(basePath);
-      res.json({ success: true, data: tree });
-    } catch (err) {
-      res.status(500).json({ success: false, error: errMsg(err) });
-    }
-  });
+    const basePath = configService.getBasePath(type);
+    const tree = configService.scanDirectory(basePath);
+    res.json({ success: true, data: tree });
+  }));
 
   // GET /config/:type/file?path=<relative> — file content
-  router.get('/config/:type/file', (req, res) => {
+  router.get('/config/:type/file', catchRoute((req, res) => {
     const type = parseType(req.params.type, res);
     if (!type) return;
 
@@ -49,19 +45,13 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
       return;
     }
 
-    try {
-      const basePath = configService.getBasePath(type);
-      const content = configService.readFile(basePath, filePath);
-      res.json({ success: true, data: { path: filePath, content } });
-    } catch (err) {
-      const msg = errMsg(err);
-      const status = msg.includes('traversal') ? 403 : msg.includes('ENOENT') || msg.includes('not found') ? 404 : 500;
-      res.status(status).json({ success: false, error: msg });
-    }
-  });
+    const basePath = configService.getBasePath(type);
+    const content = configService.readFile(basePath, filePath);
+    res.json({ success: true, data: { path: filePath, content } });
+  }, inferErrorStatus));
 
   // PUT /config/:type/file — save file { path, content }
-  router.put('/config/:type/file', (req, res) => {
+  router.put('/config/:type/file', catchRoute((req, res) => {
     const type = parseType(req.params.type, res);
     if (!type) return;
 
@@ -71,20 +61,14 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
       return;
     }
 
-    try {
-      const basePath = configService.getBasePath(type);
-      configService.writeFile(basePath, filePath, content);
-      io.emit(`config:${type}:changed`, { action: 'updated', path: filePath });
-      res.json({ success: true });
-    } catch (err) {
-      const msg = errMsg(err);
-      const status = msg.includes('traversal') ? 403 : msg.includes('not found') ? 404 : 500;
-      res.status(status).json({ success: false, error: msg });
-    }
-  });
+    const basePath = configService.getBasePath(type);
+    configService.writeFile(basePath, filePath, content);
+    io.emit(`config:${type}:changed`, { action: 'updated', path: filePath });
+    res.json({ success: true });
+  }, inferErrorStatus));
 
   // POST /config/:type/file — create file { path, content }
-  router.post('/config/:type/file', (req, res) => {
+  router.post('/config/:type/file', catchRoute((req, res) => {
     const type = parseType(req.params.type, res);
     if (!type) return;
 
@@ -94,20 +78,14 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
       return;
     }
 
-    try {
-      const basePath = configService.getBasePath(type);
-      configService.createFile(basePath, filePath, content);
-      io.emit(`config:${type}:changed`, { action: 'created', path: filePath });
-      res.status(201).json({ success: true });
-    } catch (err) {
-      const msg = errMsg(err);
-      const status = msg.includes('traversal') ? 403 : msg.includes('already exists') ? 409 : 500;
-      res.status(status).json({ success: false, error: msg });
-    }
-  });
+    const basePath = configService.getBasePath(type);
+    configService.createFile(basePath, filePath, content);
+    io.emit(`config:${type}:changed`, { action: 'created', path: filePath });
+    res.status(201).json({ success: true });
+  }, inferErrorStatus));
 
   // DELETE /config/:type/file?path=<relative> — delete file
-  router.delete('/config/:type/file', (req, res) => {
+  router.delete('/config/:type/file', catchRoute((req, res) => {
     const type = parseType(req.params.type, res);
     if (!type) return;
 
@@ -117,20 +95,14 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
       return;
     }
 
-    try {
-      const basePath = configService.getBasePath(type);
-      configService.deleteFile(basePath, filePath);
-      io.emit(`config:${type}:changed`, { action: 'deleted', path: filePath });
-      res.json({ success: true });
-    } catch (err) {
-      const msg = errMsg(err);
-      const status = msg.includes('traversal') ? 403 : msg.includes('not found') ? 404 : msg.includes('directory') ? 400 : 500;
-      res.status(status).json({ success: false, error: msg });
-    }
-  });
+    const basePath = configService.getBasePath(type);
+    configService.deleteFile(basePath, filePath);
+    io.emit(`config:${type}:changed`, { action: 'deleted', path: filePath });
+    res.json({ success: true });
+  }, inferErrorStatus));
 
   // POST /config/:type/rename — rename { oldPath, newPath }
-  router.post('/config/:type/rename', (req, res) => {
+  router.post('/config/:type/rename', catchRoute((req, res) => {
     const type = parseType(req.params.type, res);
     if (!type) return;
 
@@ -140,20 +112,14 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
       return;
     }
 
-    try {
-      const basePath = configService.getBasePath(type);
-      configService.renameFile(basePath, oldPath, newPath);
-      io.emit(`config:${type}:changed`, { action: 'renamed', oldPath, newPath });
-      res.json({ success: true });
-    } catch (err) {
-      const msg = errMsg(err);
-      const status = msg.includes('traversal') ? 403 : msg.includes('not found') ? 404 : msg.includes('already exists') ? 409 : 500;
-      res.status(status).json({ success: false, error: msg });
-    }
-  });
+    const basePath = configService.getBasePath(type);
+    configService.renameFile(basePath, oldPath, newPath);
+    io.emit(`config:${type}:changed`, { action: 'renamed', oldPath, newPath });
+    res.json({ success: true });
+  }, inferErrorStatus));
 
   // POST /config/:type/folder — create folder { path }
-  router.post('/config/:type/folder', (req, res) => {
+  router.post('/config/:type/folder', catchRoute((req, res) => {
     const type = parseType(req.params.type, res);
     if (!type) return;
 
@@ -163,17 +129,11 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
       return;
     }
 
-    try {
-      const basePath = configService.getBasePath(type);
-      configService.createFolder(basePath, folderPath);
-      io.emit(`config:${type}:changed`, { action: 'folder-created', path: folderPath });
-      res.status(201).json({ success: true });
-    } catch (err) {
-      const msg = errMsg(err);
-      const status = msg.includes('traversal') ? 403 : msg.includes('already exists') ? 409 : 500;
-      res.status(status).json({ success: false, error: msg });
-    }
-  });
+    const basePath = configService.getBasePath(type);
+    configService.createFolder(basePath, folderPath);
+    io.emit(`config:${type}:changed`, { action: 'folder-created', path: folderPath });
+    res.status(201).json({ success: true });
+  }, inferErrorStatus));
 
   return router;
 }

package/server/routes/data-routes.ts

@@ -12,26 +12,15 @@ import type { WorkflowEngine } from '../../shared/workflow-engine.js';
 import { getHookEnforcement } from '../../shared/workflow-config.js';
 import { getClaudeSessions, getSessionStats, type SessionStats } from '../services/claude-session-service.js';
 import { launchInTerminal } from '../utils/terminal-launcher.js';
+import type { OrbitalConfig } from '../config.js';
+import { buildClaudeFlags } from '../utils/flag-builder.js';
 import { createLogger } from '../utils/logger.js';
+import { parseJsonFields, type Row } from '../utils/json-fields.js';
 
 const log = createLogger('server');
 
 const execFileAsync = promisify(execFile);
 
-const JSON_FIELDS = ['tags', 'blocked_by', 'blocks', 'data', 'discoveries', 'next_steps', 'details'];
-
-type Row = Record<string, unknown>;
-
-function parseJsonFields(row: Row): Row {
-  const parsed = { ...row };
-  for (const field of JSON_FIELDS) {
-    if (typeof parsed[field] === 'string') {
-      try { parsed[field] = JSON.parse(parsed[field] as string); } catch { /* keep string */ }
-    }
-  }
-  return parsed;
-}
-
 // ─── Route Factory ──────────────────────────────────────────
 
 interface DataRouteDeps {
@@ -44,10 +33,11 @@ interface DataRouteDeps {
   engine: WorkflowEngine;
   projectRoot: string;
   inferScopeStatus: (type: string, scopeId: unknown, data: Record<string, unknown>) => void;
+  config: OrbitalConfig;
 }
 
 export function createDataRoutes({
-  db, io, eventService, gateService, deployService, gitService, engine, projectRoot, inferScopeStatus,
+  db, io, eventService, gateService, deployService, gitService, engine, projectRoot, inferScopeStatus, config,
 }: DataRouteDeps): Router {
   const router = Router();
 
@@ -353,7 +343,8 @@ export function createDataRoutes({
       return;
     }
 
-    const resumeCmd = `cd '${projectRoot}' && claude --dangerously-skip-permissions --resume '${claude_session_id}'`;
+    const flagsStr = buildClaudeFlags(config.claude.dispatchFlags);
+    const resumeCmd = `cd '${projectRoot}' && claude ${flagsStr} --resume '${claude_session_id}'`;
 
     try {
       await launchInTerminal(resumeCmd);

package/server/routes/dispatch-routes.ts

@@ -5,11 +5,13 @@ import type { ScopeService } from '../services/scope-service.js';
 import { launchInCategorizedTerminal, escapeForAnsiC, shellQuote, buildSessionName, snapshotSessionPids, discoverNewSession, renameSession } from '../utils/terminal-launcher.js';
 import { resolveDispatchEvent, resolveAbandonedDispatchesForScope, getActiveScopeIds, getAbandonedScopeIds, linkPidToDispatch } from '../utils/dispatch-utils.js';
 import type { WorkflowEngine } from '../../shared/workflow-engine.js';
+import type { OrbitalConfig } from '../config.js';
+import { buildClaudeFlags, buildEnvVarPrefix } from '../utils/flag-builder.js';
 import { createLogger } from '../utils/logger.js';
 
 const log = createLogger('dispatch');
 
-const MAX_BATCH_SIZE = 20;
+const DEFAULT_MAX_BATCH_SIZE = 20;
 
 interface DispatchBody {
   scope_id?: number;
@@ -24,9 +26,10 @@ interface DispatchRouteDeps {
   scopeService: ScopeService;
   projectRoot: string;
   engine: WorkflowEngine;
+  config: OrbitalConfig;
 }
 
-export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine }: DispatchRouteDeps): Router {
+export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine, config }: DispatchRouteDeps): Router {
   const router = Router();
 
   router.get('/dispatch/active-scopes', (_req, res) => {
@@ -79,6 +82,19 @@ export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine
       }
     }
 
+    // Max concurrent dispatches guard
+    const maxConcurrent = config.dispatch.maxConcurrent;
+    if (maxConcurrent > 0) {
+      const activeCount = (db.prepare(
+        `SELECT COUNT(*) as count FROM events
+         WHERE type = 'DISPATCH' AND JSON_EXTRACT(data, '$.resolved') IS NULL`
+      ).get() as { count: number }).count;
+      if (activeCount >= maxConcurrent) {
+        res.status(429).json({ error: `Max concurrent dispatches reached (${maxConcurrent})` });
+        return;
+      }
+    }
+
     // Update scope status if transition provided
     if (scope_id != null && transition?.to) {
       const result = scopeService.updateStatus(scope_id, transition.to, 'dispatch');
@@ -107,10 +123,12 @@ export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine
     const sessionName = buildSessionName({ scopeId: scope_id ?? undefined, title: scope?.title, command });
     const beforePids = snapshotSessionPids(projectRoot);
 
-    // Launch in iTerm — interactive TUI mode (no -p) for full visibility
+    // Launch in iTerm — interactive TUI mode (no -p unless printMode) for full visibility
     const promptText = prompt ?? command;
     const escaped = escapeForAnsiC(promptText);
-    const fullCmd = `cd '${shellQuote(projectRoot)}' && ORBITAL_DISPATCH_ID='${shellQuote(eventId)}' claude --dangerously-skip-permissions $'${escaped}'`;
+    const flagsStr = buildClaudeFlags(config.claude.dispatchFlags);
+    const envPrefix = buildEnvVarPrefix(config.dispatch.envVars);
+    const fullCmd = `cd '${shellQuote(projectRoot)}' && ${envPrefix}ORBITAL_DISPATCH_ID='${shellQuote(eventId)}' claude ${flagsStr} $'${escaped}'`;
     try {
       await launchInCategorizedTerminal(command, fullCmd, sessionName);
       res.json({ ok: true, dispatch_id: eventId, scope_id: scope_id ?? null });
@@ -215,8 +233,9 @@ export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine
     }
 
     // W-12: Validate batch size and scope ID types
-    if (scope_ids.length > MAX_BATCH_SIZE) {
-      res.status(400).json({ error: `Maximum batch size is ${MAX_BATCH_SIZE}` });
+    const maxBatch = config.dispatch.maxBatchSize || DEFAULT_MAX_BATCH_SIZE;
+    if (scope_ids.length > maxBatch) {
+      res.status(400).json({ error: `Maximum batch size is ${maxBatch}` });
       return;
     }
     if (!scope_ids.every(id => Number.isInteger(id) && id > 0)) {
@@ -249,10 +268,12 @@ export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine
       timestamp: new Date().toISOString(),
     });
 
-    // Launch single CLI session
+    // Launch single CLI session with batch env vars
     const batchEscaped = escapeForAnsiC(command);
     const beforePids = snapshotSessionPids(projectRoot);
-    const fullCmd = `cd '${shellQuote(projectRoot)}' && ORBITAL_DISPATCH_ID='${shellQuote(eventId)}' claude --dangerously-skip-permissions -p $'${batchEscaped}'`;
+    const batchFlags = buildClaudeFlags(config.claude.dispatchFlags);
+    const envPrefix = buildEnvVarPrefix(config.dispatch.envVars);
+    const fullCmd = `cd '${shellQuote(projectRoot)}' && ${envPrefix}ORBITAL_DISPATCH_ID='${shellQuote(eventId)}' claude ${batchFlags} $'${batchEscaped}'`;
     try {
       await launchInCategorizedTerminal(command, fullCmd);
       res.json({ ok: true, dispatch_id: eventId, scope_ids });

package/server/routes/manifest-routes.ts

@@ -166,7 +166,7 @@ export function createManifestRoutes({
       }
 
       if (!manifest) {
-        return res.status(400).json({ success: false, error: 'No manifest. Run orbital init first.' });
+        return res.status(400).json({ success: false, error: 'No manifest. Run orbital first.' });
       }
 
       if (dryRun) {

package/server/routes/scope-routes.ts

@@ -5,8 +5,10 @@ import type { Emitter } from '../project-emitter.js';
 import type { ScopeService } from '../services/scope-service.js';
 import type { ReadinessService } from '../services/readiness-service.js';
 import type { WorkflowEngine } from '../../shared/workflow-engine.js';
-import { launchInTerminal, escapeForAnsiC, buildSessionName, snapshotSessionPids, discoverNewSession, renameSession } from '../utils/terminal-launcher.js';
+import { launchInTerminal, escapeForAnsiC, shellQuote, buildSessionName, snapshotSessionPids, discoverNewSession, renameSession } from '../utils/terminal-launcher.js';
 import { resolveDispatchEvent, linkPidToDispatch } from '../utils/dispatch-utils.js';
+import { buildClaudeFlags, buildEnvVarPrefix } from '../utils/flag-builder.js';
+import type { OrbitalConfig } from '../config.js';
 import { createLogger } from '../utils/logger.js';
 
 const log = createLogger('dispatch');
@@ -19,13 +21,14 @@ interface ScopeRouteDeps {
   projectRoot: string;
   projectName: string;
   engine: WorkflowEngine;
+  config: OrbitalConfig;
 }
 
 function isValidSlug(slug: string): boolean {
   return /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(slug) && slug.length <= 80;
 }
 
-export function createScopeRoutes({ db, io, scopeService, readinessService, projectRoot, projectName, engine }: ScopeRouteDeps): Router {
+export function createScopeRoutes({ db, io, scopeService, readinessService, projectRoot, projectName, engine, config }: ScopeRouteDeps): Router {
   const router = Router();
 
   // ─── Scope CRUD ──────────────────────────────────────────
@@ -123,7 +126,10 @@ export function createScopeRoutes({ db, io, scopeService, readinessService, proj
   router.post('/ideas/:slug/promote', async (req, res) => {
     const { slug } = req.params;
     if (!isValidSlug(slug)) { res.status(400).json({ error: 'Invalid slug' }); return; }
-    const result = scopeService.promoteIdea(slug);
+    const entryPoint = engine.getEntryPoint();
+    const targets = engine.getValidTargets(entryPoint.id);
+    const promoteTarget = targets[0] ?? 'planning';
+    const result = scopeService.promoteIdea(slug, promoteTarget);
     if (!result) {
       res.status(404).json({ error: 'Idea not found' });
       return;
@@ -132,9 +138,6 @@ export function createScopeRoutes({ db, io, scopeService, readinessService, proj
     const scopeId = result.id;
 
     // Read command from workflow edge config (user-overridable)
-    const entryPoint = engine.getEntryPoint();
-    const targets = engine.getValidTargets(entryPoint.id);
-    const promoteTarget = targets[0] ?? 'planning';
     const edge = engine.findEdge(entryPoint.id, promoteTarget);
     const edgeCommand = edge ? engine.buildCommand(edge, scopeId) : null;
     const command = edgeCommand ?? `/scope-create ${String(scopeId).padStart(3, '0')}`;
@@ -158,7 +161,9 @@ export function createScopeRoutes({ db, io, scopeService, readinessService, proj
     });
 
     const escaped = escapeForAnsiC(command);
-    const fullCmd = `cd '${projectRoot}' && claude --dangerously-skip-permissions $'${escaped}'`;
+    const flagsStr = buildClaudeFlags(config.claude.dispatchFlags);
+    const envPrefix = buildEnvVarPrefix(config.dispatch.envVars);
+    const fullCmd = `cd '${shellQuote(projectRoot)}' && ${envPrefix}ORBITAL_DISPATCH_ID='${shellQuote(eventId)}' claude ${flagsStr} $'${escaped}'`;
 
     const promoteSessionName = buildSessionName({ scopeId, title: result.title, command });
     const promoteBeforePids = snapshotSessionPids(projectRoot);

package/server/schema.ts

@@ -89,4 +89,5 @@ CREATE INDEX IF NOT EXISTS idx_sessions_scope ON sessions(scope_id);
 CREATE INDEX IF NOT EXISTS idx_sessions_claude_id ON sessions(claude_session_id);
 CREATE INDEX IF NOT EXISTS idx_sprints_status ON sprints(status);
 CREATE INDEX IF NOT EXISTS idx_sprint_scopes_sprint ON sprint_scopes(sprint_id);
+CREATE INDEX IF NOT EXISTS idx_events_dispatch_unresolved ON events(type, scope_id) WHERE type = 'DISPATCH' AND JSON_EXTRACT(data, '$.resolved') IS NULL;
 `;

package/server/services/batch-orchestrator.ts

@@ -2,9 +2,11 @@ import type Database from 'better-sqlite3';
 import type { Emitter } from '../project-emitter.js';
 import type { SprintService } from './sprint-service.js';
 import type { ScopeService } from './scope-service.js';
-import { launchInCategorizedTerminal, escapeForAnsiC, snapshotSessionPids, discoverNewSession, isSessionPidAlive } from '../utils/terminal-launcher.js';
+import { launchInCategorizedTerminal, escapeForAnsiC, shellQuote, snapshotSessionPids, discoverNewSession, isSessionPidAlive } from '../utils/terminal-launcher.js';
 import { linkPidToDispatch, resolveDispatchEvent } from '../utils/dispatch-utils.js';
 import type { WorkflowEngine } from '../../shared/workflow-engine.js';
+import type { OrbitalConfig } from '../config.js';
+import { buildClaudeFlags, buildEnvVarPrefix } from '../utils/flag-builder.js';
 import { createLogger } from '../utils/logger.js';
 
 const log = createLogger('batch');
@@ -20,6 +22,7 @@ export class BatchOrchestrator {
     private scopeService: ScopeService,
     private engine: WorkflowEngine,
     private projectRoot: string,
+    private config: OrbitalConfig,
   ) {}
 
   /** Dispatch a batch — validates constraints and routes to column-specific handler */
@@ -70,7 +73,9 @@ export class BatchOrchestrator {
 
     // Launch single CLI session with BATCH_SCOPE_IDS prepended to command
     const escaped = escapeForAnsiC(command);
-    const fullCmd = `cd '${this.projectRoot}' && BATCH_SCOPE_IDS='${scopeIdsStr}' MERGE_MODE='${mergeModeStr}' claude --dangerously-skip-permissions $'${escaped}'`;
+    const flagsStr = buildClaudeFlags(this.config.claude.dispatchFlags);
+    const envPrefix = buildEnvVarPrefix(this.config.dispatch.envVars);
+    const fullCmd = `cd '${shellQuote(this.projectRoot)}' && ${envPrefix}ORBITAL_DISPATCH_ID='${shellQuote(eventId)}' BATCH_SCOPE_IDS='${scopeIdsStr}' MERGE_MODE='${mergeModeStr}' claude ${flagsStr} $'${escaped}'`;
     const beforePids = snapshotSessionPids(this.projectRoot);
 
     try {
@@ -148,6 +153,17 @@ export class BatchOrchestrator {
     if (batch.status !== 'dispatched' && batch.status !== 'in_progress') return;
 
     const scopes = this.sprintService.getSprintScopes(batchId);
+
+    // If batch never reached 'in_progress', the session never started —
+    // don't credit any scope regardless of their current workflow status
+    if (batch.status === 'dispatched') {
+      this.sprintService.updateStatus(batchId, 'failed');
+      for (const ss of scopes) {
+        this.sprintService.updateScopeStatus(batchId, ss.scope_id, 'failed', 'Session never started');
+      }
+      return;
+    }
+
     const allTransitioned = scopes.every((ss) => ss.dispatch_status === 'completed');
 
     if (allTransitioned) {

package/server/services/config-service.ts

@@ -120,7 +120,16 @@ export class ConfigService {
       const fullPath = path.join(currentPath, entry.name);
       const relPath = path.relative(basePath, fullPath);
 
-      if (entry.isDirectory()) {
+      // Resolve symlinks: Dirent.isDirectory() returns false for symlinks-to-dirs.
+      // Self-hosted projects symlink .claude/agents/*, .claude/hooks/*, etc. into templates/.
+      let stat: fs.Stats;
+      try {
+        stat = fs.statSync(fullPath);
+      } catch {
+        continue; // broken symlink — skip silently
+      }
+
+      if (stat.isDirectory()) {
         const children = this.walkDir(fullPath, basePath, parseFrontmatter);
         nodes.push({ name: entry.name, path: relPath, type: 'folder', children });
       } else {

package/server/services/scope-service.ts

@@ -120,7 +120,7 @@ export class ScopeService {
     const id = this.cache.removeByFilePath(filePath);
     if (id !== undefined) {
       if (previous) this.recentlyRemoved.set(id, previous.status);
-      this.io.emit('scope:deleted', id);
+      this.io.emit('scope:deleted', { id });
       // Clean up stash after a short window (if add never fires, this was a real delete)
       setTimeout(() => this.recentlyRemoved.delete(id), 5000);
     }
@@ -379,7 +379,7 @@ export class ScopeService {
 
   /** Promote an icebox idea to planning — assigns a proper sequential scope ID,
    *  moves the file, and syncs cache. Returns the new scope ID. */
-  promoteIdea(slug: string): { id: number; filePath: string; title: string; description: string } | null {
+  promoteIdea(slug: string, targetStatus = 'planning'): { id: number; filePath: string; title: string; description: string } | null {
     const iceboxDir = path.join(this.scopesDir, 'icebox');
     const oldPath = this.findIdeaFile(iceboxDir, slug);
     if (!oldPath) return null;
@@ -397,15 +397,15 @@ export class ScopeService {
 
     // Build new path
     const titleSlug = this.slugify(title);
-    const planningDir = path.join(this.scopesDir, 'planning');
-    if (!fs.existsSync(planningDir)) fs.mkdirSync(planningDir, { recursive: true });
+    const targetDir = path.join(this.scopesDir, targetStatus);
+    if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
     const newFileName = `${paddedId}-${titleSlug}.md`;
-    const newPath = path.join(planningDir, newFileName);
+    const newPath = path.join(targetDir, newFileName);
     const now = new Date().toISOString().split('T')[0];
 
     // Update frontmatter in-place: assign ID and change status (preserve other fields)
     parsed.data.id = newId;
-    parsed.data.status = 'planning';
+    parsed.data.status = targetStatus;
     parsed.data.updated = now;
     parsed.data.created = created;
     delete parsed.data.ghost;

package/server/services/sprint-orchestrator.ts

@@ -2,9 +2,11 @@ import type Database from 'better-sqlite3';
 import type { Emitter } from '../project-emitter.js';
 import { SprintService } from './sprint-service.js';
 import { ScopeService } from './scope-service.js';
-import { launchInCategorizedTerminal, escapeForAnsiC, buildSessionName, snapshotSessionPids, discoverNewSession, renameSession } from '../utils/terminal-launcher.js';
+import { launchInCategorizedTerminal, escapeForAnsiC, shellQuote, buildSessionName, snapshotSessionPids, discoverNewSession, renameSession } from '../utils/terminal-launcher.js';
 import { resolveDispatchEvent, linkPidToDispatch } from '../utils/dispatch-utils.js';
+import { buildClaudeFlags, buildEnvVarPrefix } from '../utils/flag-builder.js';
 import type { WorkflowEngine } from '../../shared/workflow-engine.js';
+import type { OrbitalConfig } from '../config.js';
 import { createLogger } from '../utils/logger.js';
 
 const log = createLogger('sprint');
@@ -24,6 +26,7 @@ export class SprintOrchestrator {
     private scopeService: ScopeService,
     private engine: WorkflowEngine,
     private projectRoot: string,
+    private config: OrbitalConfig,
   ) {}
 
   /** Build execution layers using Kahn's topological sort */
@@ -112,14 +115,16 @@ export class SprintOrchestrator {
   async onScopeReachedDev(scopeId: number): Promise<void> {
     const match = this.sprintService.findActiveSprintForScope(scopeId);
     if (!match) return;
-    log.debug('Scope reached dev', { scopeId, sprintId: match.sprint_id });
 
+    // Batches are managed by BatchOrchestrator — don't dispatch individual scopes
     const sprintId = match.sprint_id;
+    const sprint = this.sprintService.getById(sprintId);
+    if (!sprint || sprint.group_type === 'batch') return;
+
+    log.debug('Scope reached dev', { scopeId, sprintId });
     this.sprintService.updateScopeStatus(sprintId, scopeId, 'completed');
 
     // Ensure sprint is in 'in_progress' state
-    const sprint = this.sprintService.getById(sprintId);
-    if (!sprint) return;
     if (sprint.status === 'dispatched') {
       this.sprintService.updateStatus(sprintId, 'in_progress');
     }
@@ -196,7 +201,7 @@ export class SprintOrchestrator {
     const sprint = this.sprintService.getById(sprintId);
     if (!sprint) return null;
 
-    const layers = sprint.layers ?? [];
+    const layers = sprint.layers ?? this.buildExecutionLayers(sprint.scope_ids).layers;
     const sprintSet = new Set(sprint.scope_ids);
     const edges: Array<{ from: number; to: number }> = [];
 
@@ -225,9 +230,15 @@ export class SprintOrchestrator {
       const currentScope = this.scopeService.getById(scopeId);
       const previousStatus = currentScope?.status ?? 'implementing';
 
+      // Resolve command and target status from workflow engine
+      const sprint = this.sprintService.getById(sprintId);
+      const targetColumn = sprint?.target_column ?? 'backlog';
+      const edgeCommand = this.engine.getBatchCommand(targetColumn);
+      const targetStatus = this.engine.getBatchTargetStatus(targetColumn);
+
       // Record DISPATCH event
       const eventId = crypto.randomUUID();
-      const command = `/scope implement ${scopeId}`;
+      const command = edgeCommand ?? `/scope-implement ${scopeId}`;
       this.db.prepare(
         `INSERT INTO events (id, type, scope_id, session_id, agent, data, timestamp)
          VALUES (?, 'DISPATCH', ?, NULL, 'sprint-orchestrator', ?, ?)`,
@@ -241,7 +252,9 @@ export class SprintOrchestrator {
       });
 
       // Update scope + sprint_scope status
-      this.scopeService.updateStatus(scopeId, 'implementing', 'dispatch');
+      if (targetStatus) {
+        this.scopeService.updateStatus(scopeId, targetStatus, 'dispatch');
+      }
       this.sprintService.updateScopeStatus(sprintId, scopeId, 'dispatched');
 
       // Build scope-aware session name and snapshot PIDs
@@ -249,9 +262,11 @@ export class SprintOrchestrator {
       const sessionName = buildSessionName({ scopeId, title: scopeRow?.title, command });
       const beforePids = snapshotSessionPids(this.projectRoot);
 
-      // Launch in iTerm — interactive TUI mode (no -p) for full visibility
+      // Launch in iTerm — interactive TUI mode for full visibility
       const escaped = escapeForAnsiC(command);
-      const fullCmd = `cd '${this.projectRoot}' && claude --dangerously-skip-permissions $'${escaped}'`;
+      const flagsStr = buildClaudeFlags(this.config.claude.dispatchFlags);
+      const envPrefix = buildEnvVarPrefix(this.config.dispatch.envVars);
+      const fullCmd = `cd '${shellQuote(this.projectRoot)}' && ${envPrefix}ORBITAL_DISPATCH_ID='${shellQuote(eventId)}' claude ${flagsStr} $'${escaped}'`;
       try {
         await launchInCategorizedTerminal(command, fullCmd, sessionName);
 

package/server/services/sprint-service.ts

@@ -157,10 +157,10 @@ export class SprintService {
     return this.buildDetail(row);
   }
 
-  /** Delete a sprint (only if assembling) */
+  /** Delete a sprint/batch (assembling, failed, or cancelled) */
   delete(id: number): boolean {
     const row = this.db.prepare('SELECT status FROM sprints WHERE id = ?').get(id) as { status: string } | undefined;
-    if (!row || row.status !== 'assembling') return false;
+    if (!row || !['assembling', 'failed', 'cancelled', 'completed'].includes(row.status)) return false;
 
     this.db.prepare('DELETE FROM sprint_scopes WHERE sprint_id = ?').run(id);
     this.db.prepare('DELETE FROM sprints WHERE id = ?').run(id);