orbital-command 0.1.4 → 0.3.0

package/dist/server/server/utils/dispatch-utils.test.js

@@ -0,0 +1,182 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { resolveDispatchEvent, resolveActiveDispatchesForScope, resolveAbandonedDispatchesForScope, linkPidToDispatch, resolveDispatchesByPid, resolveDispatchesByDispatchId, getActiveScopeIds, getAbandonedScopeIds, } from './dispatch-utils.js';
+import { createTestDb } from '../__tests__/helpers/db.js';
+import { createMockEmitter } from '../__tests__/helpers/mock-emitter.js';
+import { WorkflowEngine } from '../../shared/workflow-engine.js';
+import { CONFIG_WITH_HOOKS } from '../../shared/__fixtures__/workflow-configs.js';
+// Mock isSessionPidAlive since it checks real OS processes
+vi.mock('./terminal-launcher.js', () => ({
+    isSessionPidAlive: vi.fn().mockReturnValue(false),
+    launchInTerminal: vi.fn(),
+    buildSessionName: vi.fn(),
+    snapshotSessionPids: vi.fn().mockReturnValue([]),
+    discoverNewSession: vi.fn(),
+    renameSession: vi.fn(),
+    launchInCategorizedTerminal: vi.fn(),
+}));
+function insertDispatchEvent(db, overrides = {}) {
+    const id = overrides.id ?? `dispatch-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    const data = JSON.stringify({
+        command: '/scope-implement 1',
+        transition: { from: 'backlog', to: 'active' },
+        ...(overrides.data ?? {}),
+    });
+    db.prepare(`INSERT INTO events (id, type, scope_id, session_id, agent, data, timestamp)
+     VALUES (?, 'DISPATCH', ?, ?, NULL, ?, ?)`).run(id, overrides.scope_id ?? 1, overrides.session_id ?? 'sess-1', data, overrides.timestamp ?? new Date().toISOString());
+    return id;
+}
+describe('dispatch-utils', () => {
+    let db;
+    let cleanup;
+    let emitter;
+    let engine;
+    beforeEach(() => {
+        ({ db, cleanup } = createTestDb());
+        emitter = createMockEmitter();
+        engine = new WorkflowEngine(CONFIG_WITH_HOOKS);
+    });
+    afterEach(() => {
+        cleanup?.();
+    });
+    // ─── resolveDispatchEvent() ───────────────────────────────
+    describe('resolveDispatchEvent()', () => {
+        it('marks dispatch as resolved with outcome', () => {
+            const id = insertDispatchEvent(db);
+            resolveDispatchEvent(db, emitter, id, 'completed');
+            const row = db.prepare('SELECT data FROM events WHERE id = ?').get(id);
+            const data = JSON.parse(row.data);
+            expect(data.resolved).toBeDefined();
+            expect(data.resolved.outcome).toBe('completed');
+            expect(data.resolved.at).toBeDefined();
+        });
+        it('emits dispatch:resolved event', () => {
+            const id = insertDispatchEvent(db);
+            resolveDispatchEvent(db, emitter, id, 'completed');
+            expect(emitter.emit).toHaveBeenCalledWith('dispatch:resolved', expect.objectContaining({ event_id: id }));
+        });
+        it('stores error message for failed dispatches', () => {
+            const id = insertDispatchEvent(db);
+            resolveDispatchEvent(db, emitter, id, 'failed', 'Timeout');
+            const row = db.prepare('SELECT data FROM events WHERE id = ?').get(id);
+            const data = JSON.parse(row.data);
+            expect(data.resolved.outcome).toBe('failed');
+            expect(data.resolved.error).toBe('Timeout');
+        });
+    });
+    // ─── resolveActiveDispatchesForScope() ────────────────────
+    describe('resolveActiveDispatchesForScope()', () => {
+        it('resolves all unresolved dispatches for a scope', () => {
+            insertDispatchEvent(db, { id: 'd1', scope_id: 42 });
+            insertDispatchEvent(db, { id: 'd2', scope_id: 42 });
+            insertDispatchEvent(db, { id: 'd3', scope_id: 99 }); // different scope
+            resolveActiveDispatchesForScope(db, emitter, 42, 'completed');
+            const rows = db.prepare("SELECT data FROM events WHERE scope_id = 42").all();
+            for (const row of rows) {
+                const data = JSON.parse(row.data);
+                expect(data.resolved).toBeDefined();
+                expect(data.resolved.outcome).toBe('completed');
+            }
+            // Scope 99 should NOT be resolved
+            const other = db.prepare("SELECT data FROM events WHERE scope_id = 99").get();
+            expect(JSON.parse(other.data).resolved).toBeUndefined();
+        });
+        it('handles no active dispatches gracefully', () => {
+            expect(() => resolveActiveDispatchesForScope(db, emitter, 999, 'completed')).not.toThrow();
+        });
+    });
+    // ─── resolveAbandonedDispatchesForScope() ─────────────────
+    describe('resolveAbandonedDispatchesForScope()', () => {
+        it('resolves abandoned dispatches as completed', () => {
+            insertDispatchEvent(db, { scope_id: 42, data: { resolved: true, outcome: 'abandoned' } });
+            const count = resolveAbandonedDispatchesForScope(db, emitter, 42);
+            expect(count).toBeGreaterThanOrEqual(0);
+        });
+    });
+    // ─── linkPidToDispatch() ──────────────────────────────────
+    describe('linkPidToDispatch()', () => {
+        it('stores PID in event data', () => {
+            const id = insertDispatchEvent(db);
+            linkPidToDispatch(db, id, 12345);
+            const row = db.prepare('SELECT data FROM events WHERE id = ?').get(id);
+            const data = JSON.parse(row.data);
+            expect(data.pid).toBe(12345);
+        });
+        it('handles non-existent event gracefully', () => {
+            expect(() => linkPidToDispatch(db, 'nonexistent', 12345)).not.toThrow();
+        });
+    });
+    // ─── resolveDispatchesByPid() ─────────────────────────────
+    describe('resolveDispatchesByPid()', () => {
+        it('resolves dispatches matching PID', () => {
+            const id = insertDispatchEvent(db, { scope_id: 1 });
+            linkPidToDispatch(db, id, 54321);
+            const ids = resolveDispatchesByPid(db, emitter, 54321);
+            expect(ids).toHaveLength(1);
+            expect(ids[0]).toBe(id);
+            const row = db.prepare('SELECT data FROM events WHERE id = ?').get(id);
+            expect(JSON.parse(row.data).resolved).toBeDefined();
+        });
+        it('returns empty array when no dispatches match PID', () => {
+            expect(resolveDispatchesByPid(db, emitter, 99999)).toHaveLength(0);
+        });
+    });
+    // ─── resolveDispatchesByDispatchId() ──────────────────────
+    describe('resolveDispatchesByDispatchId()', () => {
+        it('resolves single dispatch by event ID', () => {
+            const id = insertDispatchEvent(db);
+            const ids = resolveDispatchesByDispatchId(db, emitter, id);
+            expect(ids).toHaveLength(1);
+            expect(ids[0]).toBe(id);
+        });
+        it('returns empty array for non-existent dispatch', () => {
+            expect(resolveDispatchesByDispatchId(db, emitter, 'nonexistent')).toHaveLength(0);
+        });
+    });
+    // ─── getActiveScopeIds() ──────────────────────────────────
+    describe('getActiveScopeIds()', () => {
+        it('returns scope IDs with unresolved dispatches', () => {
+            insertDispatchEvent(db, { scope_id: 10 });
+            insertDispatchEvent(db, { scope_id: 20 });
+            const mockScopeService = {
+                getById: (id) => ({ id, status: 'active' }),
+            };
+            const ids = getActiveScopeIds(db, mockScopeService, engine);
+            // May return empty if dispatches are stale (PID check fails), but shouldn't throw
+            expect(Array.isArray(ids)).toBe(true);
+        });
+        it('excludes scopes in terminal status', () => {
+            insertDispatchEvent(db, { scope_id: 30 });
+            const mockScopeService = {
+                getById: (id) => ({ id, status: 'shipped' }), // terminal
+            };
+            const ids = getActiveScopeIds(db, mockScopeService, engine);
+            expect(ids).not.toContain(30);
+        });
+    });
+    // ─── getAbandonedScopeIds() ───────────────────────────────
+    describe('getAbandonedScopeIds()', () => {
+        it('returns recently abandoned scopes', () => {
+            insertDispatchEvent(db, {
+                scope_id: 50,
+                data: { resolved: true, outcome: 'abandoned', resolved_at: new Date().toISOString(), transition: { from: 'backlog', to: 'active' } },
+            });
+            const mockScopeService = {
+                getById: (id) => ({ id, status: 'active' }),
+            };
+            const abandoned = getAbandonedScopeIds(db, mockScopeService, engine);
+            expect(Array.isArray(abandoned)).toBe(true);
+        });
+        it('excludes terminal scopes', () => {
+            insertDispatchEvent(db, {
+                scope_id: 60,
+                data: { resolved: true, outcome: 'abandoned', resolved_at: new Date().toISOString(), transition: { from: 'review', to: 'shipped' } },
+            });
+            const mockScopeService = {
+                getById: (id) => ({ id, status: 'shipped' }), // terminal
+            };
+            const abandoned = getAbandonedScopeIds(db, mockScopeService, engine);
+            const ids = abandoned.map(a => a.scope_id);
+            expect(ids).not.toContain(60);
+        });
+    });
+});

package/dist/server/server/utils/logger.js

@@ -24,8 +24,14 @@ const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
 const c = {
     reset: useColor ? '\x1b[0m' : '',
     dim: useColor ? '\x1b[2m' : '',
-    gray: useColor ? '\x1b[90m' : '',
+    green: useColor ? '\x1b[32m' : '',
+    blue: useColor ? '\x1b[34m' : '',
+    magenta: useColor ? '\x1b[35m' : '',
     cyan: useColor ? '\x1b[36m' : '',
+    white: useColor ? '\x1b[37m' : '',
+    gray: useColor ? '\x1b[90m' : '',
+    brightMagenta: useColor ? '\x1b[95m' : '',
+    brightCyan: useColor ? '\x1b[96m' : '',
     yellow: useColor ? '\x1b[33m' : '',
     red: useColor ? '\x1b[31m' : '',
 };
@@ -41,6 +47,31 @@ const LEVEL_LABEL = {
     warn: 'WARN ',
     error: 'ERROR',
 };
+// ─── Component Colors ───────────────────────────────────────
+const COMPONENT_COLOR = {
+    // Scope (green)
+    'scope': c.green, 'scope-watcher': c.green,
+    // Dispatch (magenta)
+    'dispatch': c.magenta, 'dispatch-utils': c.magenta, 'batch': c.magenta,
+    // Git (blue)
+    'git': c.blue, 'worktree': c.blue,
+    // Workflow (cyan)
+    'workflow': c.cyan, 'sprint': c.cyan,
+    // Sync / Config (yellow)
+    'sync': c.yellow, 'config': c.yellow, 'manifest': c.yellow, 'global-config': c.yellow,
+    // Events (white)
+    'event': c.white, 'event-watcher': c.white, 'global-watcher': c.white,
+    // Infrastructure (white)
+    'server': c.white, 'central': c.white, 'database': c.white,
+    'project-context': c.white, 'project-manager': c.white, 'launch': c.white,
+    // Terminal (bright magenta)
+    'terminal': c.brightMagenta,
+    // Services (bright cyan)
+    'gate': c.brightCyan, 'deploy': c.brightCyan, 'telemetry': c.brightCyan, 'version': c.brightCyan,
+};
+function componentColor(name) {
+    return COMPONENT_COLOR[name] ?? c.dim;
+}
 // ─── Formatting ─────────────────────────────────────────────
 function timestamp() {
     const d = new Date();
@@ -65,10 +96,13 @@ function formatData(data) {
 function write(level, component, msg, data) {
     if (LEVEL_VALUE[level] < LEVEL_VALUE[currentLevel])
         return;
-    const color = LEVEL_COLOR[level];
+    const lvl = LEVEL_COLOR[level];
     const label = LEVEL_LABEL[level];
     const kv = formatData(data);
-    const line = `${c.dim}${timestamp()}${c.reset} ${color}${label}${c.reset} ${c.dim}[${component}]${c.reset} ${msg}${kv}\n`;
+    const cc = componentColor(component);
+    // Message uses level color for warn/error (urgency), component color otherwise
+    const mc = (level === 'warn' || level === 'error') ? lvl : cc;
+    const line = `${c.dim}${timestamp()}${c.reset} ${lvl}${label}${c.reset} ${cc}[${component}]${c.reset} ${mc}${msg}${c.reset}${c.dim}${kv}${c.reset}\n`;
     if (level === 'warn' || level === 'error') {
         process.stderr.write(line);
     }

package/dist/server/server/utils/package-info.js

@@ -0,0 +1,30 @@
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+const __selfDir = path.dirname(fileURLToPath(import.meta.url));
+/**
+ * Resolve the root directory of the orbital-command package itself.
+ * Walks up from the current file until it finds package.json.
+ */
+export function getOrbitalRoot() {
+    let dir = __selfDir;
+    for (let i = 0; i < 6; i++) {
+        if (fs.existsSync(path.join(dir, 'package.json'))) {
+            return dir;
+        }
+        dir = path.dirname(dir);
+    }
+    // Fallback: assume dev layout (server/utils/ → 2 levels up)
+    return path.resolve(__selfDir, '../..');
+}
+/** Read package version from package.json in the given root, or the orbital root. */
+export function getPackageVersion(rootDir) {
+    try {
+        const dir = rootDir ?? getOrbitalRoot();
+        const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'));
+        return pkg.version || '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}

package/dist/server/server/utils/route-helpers.js

@@ -0,0 +1,10 @@
+import path from 'path';
+/** Extract a human-readable message from an unknown error value. */
+export function errMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/** Validate that a relative path stays within bounds (no traversal). */
+export function isValidRelativePath(p) {
+    const normalized = path.normalize(p);
+    return !normalized.startsWith('..') && !path.isAbsolute(normalized) && !normalized.includes('\0');
+}

package/dist/server/server/utils/terminal-launcher.js

@@ -41,21 +41,29 @@ const FALLBACK_HEX = '#6B7280'; // neutral gray if no column match
 function profilesFilename(prefix) {
     return `${prefix.toLowerCase()}-dispatch-profiles.json`;
 }
-function buildProfiles(colorMap) {
-    const prefix = getConfig().terminal.profilePrefix;
+function buildProfiles(colorMap, profilePrefix, parentColors) {
+    const prefix = profilePrefix ?? getConfig().terminal.profilePrefix;
+    const useSeparateColors = parentColors?.['Use Separate Colors for Light and Dark Mode'] === true;
     return {
-        Profiles: CATEGORY_COLUMN_CANDIDATES.map(({ category }) => ({
-            Name: `${prefix}-${category}`,
-            Guid: deriveGuid(prefix, category),
-            'Dynamic Profile Parent Name': 'Default',
-            'Custom Window Title': category,
-            'Use Custom Window Title': true,
-            'Allow Title Setting': false,
-            'Title Components': 1, // 1 = Session Name (not Job Name)
-            'Badge Text': category,
-            'Tab Color': hexToItermColor(colorMap.get(category) ?? FALLBACK_HEX),
-            'Use Tab Color': true,
-        })),
+        Profiles: CATEGORY_COLUMN_CANDIDATES.map(({ category }) => {
+            const stageColor = hexToItermColor(colorMap.get(category) ?? FALLBACK_HEX);
+            const badgeColor = { ...stageColor, 'Alpha Component': 0.5 };
+            return {
+                ...(parentColors ?? {}), // inherited colors first — our overrides win
+                Name: `${prefix}-${category}`,
+                Guid: deriveGuid(prefix, category),
+                'Dynamic Profile Parent Name': 'Default',
+                'Custom Window Title': category,
+                'Use Custom Window Title': true,
+                'Allow Title Setting': false,
+                'Title Components': 1, // 1 = Session Name (not Job Name)
+                'Badge Text': category,
+                'Tab Color': stageColor,
+                'Use Tab Color': true,
+                'Badge Color': badgeColor,
+                ...(useSeparateColors ? { 'Badge Color (Dark)': badgeColor, 'Badge Color (Light)': badgeColor } : {}),
+            };
+        }),
     };
 }
 /** Resolve tab colors from the active workflow's column hex values. */
@@ -72,28 +80,61 @@ function resolveColorMap(engine) {
     }
     return colors;
 }
+const ITERM2_PLIST = path.join(os.homedir(), 'Library', 'Preferences', 'com.googlecode.iterm2.plist');
+/** Read all color properties from the user's iTerm2 parent profile.
+ *  Uses `plutil -extract` to pull the first bookmark as JSON, then filters
+ *  for color dicts (entries with "Red Component") and the separate-colors flag.
+ *  Returns an empty object on non-macOS or if iTerm2 prefs can't be read. */
+async function readParentProfileColors() {
+    try {
+        const { stdout } = await execFileAsync('plutil', ['-extract', 'New Bookmarks.0', 'json', '-o', '-', ITERM2_PLIST], { timeout: 5000 });
+        const profile = JSON.parse(stdout);
+        const colors = {};
+        for (const [key, value] of Object.entries(profile)) {
+            if (value && typeof value === 'object' && 'Red Component' in value) {
+                colors[key] = value;
+            }
+            if (key === 'Use Separate Colors for Light and Dark Mode') {
+                colors[key] = value;
+            }
+        }
+        return colors;
+    }
+    catch {
+        return {};
+    }
+}
 /** Write iTerm2 Dynamic Profiles for each workflow category.
  *  Derives tab colors from the active workflow's column definitions.
+ *  Reads the parent profile's colors to work around iTerm2's incomplete
+ *  inheritance of (Dark)/(Light) color variants.
  *  Idempotent — safe to call on every server startup. */
-export async function ensureDynamicProfiles(engine) {
+const profilesWritten = new Set();
+export async function ensureDynamicProfiles(engine, profilePrefix) {
+    const prefix = profilePrefix ?? getConfig().terminal.profilePrefix;
+    if (profilesWritten.has(prefix))
+        return;
+    profilesWritten.add(prefix);
     try {
         await fs.mkdir(DYNAMIC_PROFILES_DIR, { recursive: true });
-        const prefix = getConfig().terminal.profilePrefix;
         const filePath = path.join(DYNAMIC_PROFILES_DIR, profilesFilename(prefix));
         const colorMap = resolveColorMap(engine);
-        // Write tmp file outside DynamicProfiles/ — iTerm2 watches that dir and reads ALL files
-        const tmpPath = path.join(os.tmpdir(), profilesFilename(prefix) + '.tmp');
-        await fs.writeFile(tmpPath, JSON.stringify(buildProfiles(colorMap), null, 2));
+        const parentColors = await readParentProfileColors();
+        // Write tmp file outside DynamicProfiles/ — iTerm2 watches that dir and reads ALL files.
+        // Use pid + timestamp to avoid races when multiple projects call concurrently.
+        const tmpPath = path.join(os.tmpdir(), `${profilesFilename(prefix)}.${process.pid}.${Date.now()}.tmp`);
+        await fs.writeFile(tmpPath, JSON.stringify(buildProfiles(colorMap, prefix, parentColors), null, 2));
         await fs.copyFile(tmpPath, filePath);
         await fs.unlink(tmpPath).catch(() => { });
+        log.info('iTerm2 profiles ready', { categories: CATEGORY_COLUMN_CANDIDATES.length });
     }
     catch (err) {
-        log.warn('Failed to write iTerm2 dynamic profiles', { error: err.message });
+        log.warn('iTerm2 profiles failed', { error: err.message });
     }
 }
 /** Maps a WindowCategory to its iTerm2 profile name. */
-function profileNameForCategory(category) {
-    return `${getConfig().terminal.profilePrefix}-${category}`;
+function profileNameForCategory(category, profilePrefix) {
+    return `${profilePrefix ?? getConfig().terminal.profilePrefix}-${category}`;
 }
 /** Ordered array — maps command prefixes to window categories */
 const COMMAND_WINDOW_MAP = [
@@ -116,6 +157,11 @@ export function commandToWindowCategory(command) {
 }
 /** In-memory registry: category → iTerm2 window ID (stable integer). Resets on server restart. */
 const windowRegistry = new Map();
+/** Escape a value for use inside single quotes in shell commands.
+ *  Replaces ' with '\'' (end quote, escaped quote, reopen quote). */
+export function shellQuote(s) {
+    return s.replace(/'/g, "'\\''");
+}
 /**
  * Escape a string for use inside $'...' ANSI-C quoting.
  * Handles backslash, single-quote, and newline characters.
@@ -177,9 +223,14 @@ async function createWindowWithCommand(command, category, tabName) {
             '-e', '  return id of newWindow',
             '-e', 'end tell',
         ]);
-        return parseInt(stdout.trim(), 10);
+        const id = parseInt(stdout.trim(), 10);
+        if (isNaN(id))
+            throw new Error('Failed to parse iTerm2 window ID');
+        return id;
     }
-    catch {
+    catch (e) {
+        if (e instanceof Error && e.message === 'Failed to parse iTerm2 window ID')
+            throw e;
         // Profile missing — fall back to default profile
         const { stdout } = await execFileAsync('osascript', [
             '-e', 'tell application "iTerm2"',
@@ -193,7 +244,10 @@ async function createWindowWithCommand(command, category, tabName) {
             '-e', '  return id of newWindow',
             '-e', 'end tell',
         ]);
-        return parseInt(stdout.trim(), 10);
+        const id = parseInt(stdout.trim(), 10);
+        if (isNaN(id))
+            throw new Error('Failed to parse iTerm2 window ID');
+        return id;
     }
 }
 /**

package/dist/server/server/utils/worktree-manager.js

@@ -2,10 +2,13 @@ import { execFile as execFileCb } from 'child_process';
 import { promisify } from 'util';
 import fs from 'fs/promises';
 import path from 'path';
+import { createLogger } from './logger.js';
 const execFile = promisify(execFileCb);
+const log = createLogger('worktree');
 export async function createWorktree(projectRoot, scopeId) {
     const wtPath = path.join(projectRoot, '.worktrees', `scope-${scopeId}`);
     const branch = `feat/scope-${scopeId}`;
+    log.info('Creating worktree', { scopeId, branch });
     await execFile('git', ['worktree', 'add', wtPath, '-b', branch], { cwd: projectRoot });
     // Ensure scopes/ and .claude/ are in .gitignore (for user projects)
     const gitignorePath = path.join(projectRoot, '.gitignore');
@@ -44,14 +47,19 @@ export async function createWorktree(projectRoot, scopeId) {
 export async function removeWorktree(projectRoot, scopeId) {
     const wtPath = path.join(projectRoot, '.worktrees', `scope-${scopeId}`);
     const branch = `feat/scope-${scopeId}`;
+    log.info('Removing worktree', { scopeId });
     try {
         await execFile('git', ['worktree', 'remove', wtPath, '--force'], { cwd: projectRoot });
     }
-    catch { /* worktree may already be gone */ }
+    catch {
+        log.debug('Worktree already removed', { scopeId });
+    }
     try {
         await execFile('git', ['branch', '-d', branch], { cwd: projectRoot });
     }
-    catch { /* branch may not exist or not be merged */ }
+    catch {
+        log.debug('Branch not deleted', { branch, scopeId });
+    }
 }
 export async function listWorktrees(projectRoot) {
     const { stdout } = await execFile('git', ['worktree', 'list', '--porcelain'], { cwd: projectRoot });
@@ -68,7 +76,7 @@ export async function listWorktrees(projectRoot) {
         else if (line === '' && currentPath) {
             const match = currentPath.match(/scope-(\d+)$/);
             if (match) {
-                results.push({ path: currentPath, branch: currentBranch, scopeId: parseInt(match[1]) });
+                results.push({ path: currentPath, branch: currentBranch, scopeId: parseInt(match[1], 10) });
             }
             currentPath = '';
             currentBranch = '';
@@ -77,7 +85,7 @@ export async function listWorktrees(projectRoot) {
     if (currentPath) {
         const match = currentPath.match(/scope-(\d+)$/);
         if (match) {
-            results.push({ path: currentPath, branch: currentBranch, scopeId: parseInt(match[1]) });
+            results.push({ path: currentPath, branch: currentBranch, scopeId: parseInt(match[1], 10) });
         }
     }
     return results;
@@ -90,6 +98,7 @@ export async function cleanupStaleWorktrees(projectRoot) {
             await fs.access(wt.path);
         }
         catch {
+            log.info('Cleaning stale worktree', { scopeId: wt.scopeId, path: wt.path });
             await removeWorktree(projectRoot, wt.scopeId);
             cleaned++;
         }