orbital-command 0.3.0 → 1.0.1

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

@@ -1,6 +1,6 @@
 import { Router } from 'express';
 import { ConfigService, isValidPrimitiveType } from '../services/config-service.js';
-import { errMsg } from '../utils/route-helpers.js';
+import { catchRoute, inferErrorStatus } from '../utils/route-helpers.js';
 export function createConfigRoutes({ projectRoot, workflowService: _workflowService, io }) {
     const router = Router();
     const configService = new ConfigService(projectRoot);
@@ -13,21 +13,16 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
         return typeParam;
     }
     // 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;
@@ -36,19 +31,12 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
             res.status(400).json({ success: false, error: 'path query parameter is required' });
             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;
@@ -57,20 +45,13 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
             res.status(400).json({ success: false, error: 'path and content are required' });
             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;
@@ -79,20 +60,13 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
             res.status(400).json({ success: false, error: 'path and content are required' });
             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;
@@ -101,20 +75,13 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
             res.status(400).json({ success: false, error: 'path query parameter is required' });
             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;
@@ -123,20 +90,13 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
             res.status(400).json({ success: false, error: 'oldPath and newPath are required' });
             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;
@@ -145,17 +105,10 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
             res.status(400).json({ success: false, error: 'path is required' });
             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/dist/server/server/routes/data-routes.js

@@ -5,23 +5,12 @@ import { promisify } from 'util';
 import { getHookEnforcement } from '../../shared/workflow-config.js';
 import { getClaudeSessions, getSessionStats } from '../services/claude-session-service.js';
 import { launchInTerminal } from '../utils/terminal-launcher.js';
+import { buildClaudeFlags } from '../utils/flag-builder.js';
 import { createLogger } from '../utils/logger.js';
+import { parseJsonFields } 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'];
-function parseJsonFields(row) {
-    const parsed = { ...row };
-    for (const field of JSON_FIELDS) {
-        if (typeof parsed[field] === 'string') {
-            try {
-                parsed[field] = JSON.parse(parsed[field]);
-            }
-            catch { /* keep string */ }
-        }
-    }
-    return parsed;
-}
-export function createDataRoutes({ db, io, eventService, gateService, deployService, gitService, engine, projectRoot, inferScopeStatus, }) {
+export function createDataRoutes({ db, io, eventService, gateService, deployService, gitService, engine, projectRoot, inferScopeStatus, config, }) {
     const router = Router();
     // ─── Event Routes ──────────────────────────────────────────
     router.get('/events', (req, res) => {
@@ -289,7 +278,8 @@ export function createDataRoutes({ db, io, eventService, gateService, deployServ
             res.status(400).json({ error: 'Valid claude_session_id (UUID) required' });
             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);
             res.json({ ok: true, session_id: claude_session_id });

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

@@ -1,10 +1,11 @@
 import { Router } from 'express';
 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 { buildClaudeFlags, buildEnvVarPrefix } from '../utils/flag-builder.js';
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('dispatch');
-const MAX_BATCH_SIZE = 20;
-export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine }) {
+const DEFAULT_MAX_BATCH_SIZE = 20;
+export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine, config }) {
     const router = Router();
     router.get('/dispatch/active-scopes', (_req, res) => {
         const scope_ids = getActiveScopeIds(db, scopeService, engine);
@@ -44,6 +45,16 @@ export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine
                 return;
             }
         }
+        // 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().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');
@@ -66,10 +77,12 @@ export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine
         const scope = scope_id != null ? scopeService.getById(scope_id) : undefined;
         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 });
@@ -160,8 +173,9 @@ export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine
             return;
         }
         // 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)) {
@@ -188,10 +202,12 @@ export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine
             session_id: null, agent: 'dashboard', data: eventData,
             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/dist/server/server/routes/manifest-routes.js

@@ -120,7 +120,7 @@ export function createManifestRoutes({ projectRoot, templatesDir, packageVersion
                 manifest = loadManifest(projectRoot);
             }
             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) {
                 refreshFileStatuses(manifest, claudeDir);

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

@@ -1,13 +1,14 @@
 import { Router } from 'express';
 import { spawn } from 'child_process';
-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 { createLogger } from '../utils/logger.js';
 const log = createLogger('dispatch');
 function isValidSlug(slug) {
     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 }) {
+export function createScopeRoutes({ db, io, scopeService, readinessService, projectRoot, projectName, engine, config }) {
     const router = Router();
     // ─── Scope CRUD ──────────────────────────────────────────
     router.get('/scopes', (_req, res) => {
@@ -103,16 +104,16 @@ export function createScopeRoutes({ db, io, scopeService, readinessService, proj
             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;
         }
         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')}`;
@@ -131,7 +132,9 @@ export function createScopeRoutes({ db, io, scopeService, readinessService, proj
             timestamp: new Date().toISOString(),
         });
         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);
         try {

package/dist/server/server/schema.js

@@ -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/dist/server/server/services/batch-orchestrator.js

@@ -1,5 +1,6 @@
-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 { buildClaudeFlags, buildEnvVarPrefix } from '../utils/flag-builder.js';
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('batch');
 const VALID_MERGE_MODES = ['push', 'pr'];
@@ -11,13 +12,15 @@ export class BatchOrchestrator {
     scopeService;
     engine;
     projectRoot;
-    constructor(db, io, sprintService, scopeService, engine, projectRoot) {
+    config;
+    constructor(db, io, sprintService, scopeService, engine, projectRoot, config) {
         this.db = db;
         this.io = io;
         this.sprintService = sprintService;
         this.scopeService = scopeService;
         this.engine = engine;
         this.projectRoot = projectRoot;
+        this.config = config;
     }
     /** Dispatch a batch — validates constraints and routes to column-specific handler */
     async dispatch(batchId, mergeMode) {
@@ -63,7 +66,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 {
             await launchInCategorizedTerminal(command, fullCmd);
@@ -137,6 +142,15 @@ 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) {
             this.sprintService.updateStatus(batchId, 'completed');

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

@@ -100,7 +100,16 @@ export class ConfigService {
                 continue;
             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;
+            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 });
             }

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

@@ -112,7 +112,7 @@ export class ScopeService {
         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);
         }
@@ -346,7 +346,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) {
+    promoteIdea(slug, targetStatus = 'planning') {
         const iceboxDir = path.join(this.scopesDir, 'icebox');
         const oldPath = this.findIdeaFile(iceboxDir, slug);
         if (!oldPath)
@@ -362,15 +362,15 @@ export class ScopeService {
         const paddedId = String(newId).padStart(3, '0');
         // 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/dist/server/server/services/sprint-orchestrator.js

@@ -1,5 +1,6 @@
-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 { createLogger } from '../utils/logger.js';
 const log = createLogger('sprint');
 const LAUNCH_STAGGER_MS = 2000;
@@ -14,13 +15,15 @@ export class SprintOrchestrator {
     scopeService;
     engine;
     projectRoot;
-    constructor(db, io, sprintService, scopeService, engine, projectRoot) {
+    config;
+    constructor(db, io, sprintService, scopeService, engine, projectRoot, config) {
         this.db = db;
         this.io = io;
         this.sprintService = sprintService;
         this.scopeService = scopeService;
         this.engine = engine;
         this.projectRoot = projectRoot;
+        this.config = config;
     }
     /** Build execution layers using Kahn's topological sort */
     buildExecutionLayers(sprintScopeIds) {
@@ -98,13 +101,14 @@ export class SprintOrchestrator {
         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;
-        this.sprintService.updateScopeStatus(sprintId, scopeId, 'completed');
-        // Ensure sprint is in 'in_progress' state
         const sprint = this.sprintService.getById(sprintId);
-        if (!sprint)
+        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
         if (sprint.status === 'dispatched') {
             this.sprintService.updateStatus(sprintId, 'in_progress');
         }
@@ -169,7 +173,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 = [];
         for (const scopeId of sprint.scope_ids) {
@@ -192,9 +196,14 @@ export class SprintOrchestrator {
             // Capture current status before optimistic update (for rollback)
             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', ?, ?)`).run(eventId, scopeId, JSON.stringify({ command, sprint_id: sprintId, resolved: null }), new Date().toISOString());
             this.io.emit('event:new', {
@@ -204,15 +213,19 @@ export class SprintOrchestrator {
                 timestamp: new Date().toISOString(),
             });
             // 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
             const scopeRow = this.scopeService.getById(scopeId);
             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);
                 // Fire-and-forget: discover session PID, link to dispatch, and rename

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

@@ -73,10 +73,10 @@ export class SprintService {
             return null;
         return this.buildDetail(row);
     }
-    /** Delete a sprint (only if assembling) */
+    /** Delete a sprint/batch (assembling, failed, or cancelled) */
     delete(id) {
         const row = this.db.prepare('SELECT status FROM sprints WHERE id = ?').get(id);
-        if (!row || row.status !== 'assembling')
+        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);