orbital-command 0.2.0 → 1.0.0

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

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest';
+import express from 'express';
+import request from 'supertest';
+import { errMsg, isValidRelativePath, inferErrorStatus, catchRoute } from './route-helpers.js';
+// ─── errMsg ─────────────────────────────────────────────────
+describe('errMsg', () => {
+    it('extracts message from Error instances', () => {
+        expect(errMsg(new Error('something broke'))).toBe('something broke');
+    });
+    it('converts non-Error values to strings', () => {
+        expect(errMsg('raw string')).toBe('raw string');
+        expect(errMsg(42)).toBe('42');
+        expect(errMsg(null)).toBe('null');
+        expect(errMsg(undefined)).toBe('undefined');
+    });
+});
+// ─── isValidRelativePath ────────────────────────────────────
+describe('isValidRelativePath', () => {
+    it('accepts normal relative paths', () => {
+        expect(isValidRelativePath('hooks/init.sh')).toBe(true);
+        expect(isValidRelativePath('agents/attacker/AGENT.md')).toBe(true);
+        expect(isValidRelativePath('file.txt')).toBe(true);
+    });
+    it('rejects directory traversal', () => {
+        expect(isValidRelativePath('../etc/passwd')).toBe(false);
+        expect(isValidRelativePath('hooks/../../secret')).toBe(false);
+    });
+    it('rejects absolute paths', () => {
+        expect(isValidRelativePath('/etc/passwd')).toBe(false);
+    });
+    it('rejects null bytes', () => {
+        expect(isValidRelativePath('file\0.txt')).toBe(false);
+    });
+});
+// ─── inferErrorStatus ───────────────────────────────────────
+describe('inferErrorStatus', () => {
+    it('returns 403 for traversal errors', () => {
+        expect(inferErrorStatus('Path traversal detected')).toBe(403);
+        expect(inferErrorStatus('directory traversal not allowed')).toBe(403);
+    });
+    it('returns 404 for not-found errors', () => {
+        expect(inferErrorStatus('File not found')).toBe(404);
+        expect(inferErrorStatus('ENOENT: no such file')).toBe(404);
+    });
+    it('returns 409 for already-exists errors', () => {
+        expect(inferErrorStatus('File already exists at path')).toBe(409);
+    });
+    it('returns 400 for directory errors', () => {
+        expect(inferErrorStatus('Cannot delete directory')).toBe(400);
+    });
+    it('returns 500 for unrecognized errors', () => {
+        expect(inferErrorStatus('something unexpected')).toBe(500);
+        expect(inferErrorStatus('')).toBe(500);
+    });
+    it('matches the first keyword when multiple are present', () => {
+        // "traversal" comes first in the chain, should win
+        expect(inferErrorStatus('traversal not found')).toBe(403);
+    });
+});
+// ─── catchRoute ─────────────────────────────────────────────
+describe('catchRoute', () => {
+    function createApp(handler) {
+        const app = express();
+        app.get('/test', handler);
+        return app;
+    }
+    it('returns normal response when handler succeeds', async () => {
+        const app = createApp(catchRoute((_req, res) => {
+            res.json({ ok: true });
+        }));
+        const res = await request(app).get('/test');
+        expect(res.status).toBe(200);
+        expect(res.body).toEqual({ ok: true });
+    });
+    it('catches sync throws and returns 500', async () => {
+        const app = createApp(catchRoute(() => {
+            throw new Error('sync failure');
+        }));
+        const res = await request(app).get('/test');
+        expect(res.status).toBe(500);
+        expect(res.body).toEqual({ success: false, error: 'sync failure' });
+    });
+    it('catches async throws and returns 500', async () => {
+        const app = createApp(catchRoute(async () => {
+            throw new Error('async failure');
+        }));
+        const res = await request(app).get('/test');
+        expect(res.status).toBe(500);
+        expect(res.body).toEqual({ success: false, error: 'async failure' });
+    });
+    it('uses custom statusFn for error status codes', async () => {
+        const app = createApp(catchRoute(() => {
+            throw new Error('File not found at path');
+        }, inferErrorStatus));
+        const res = await request(app).get('/test');
+        expect(res.status).toBe(404);
+        expect(res.body).toEqual({ success: false, error: 'File not found at path' });
+    });
+    it('uses custom statusFn for traversal errors', async () => {
+        const app = createApp(catchRoute(() => {
+            throw new Error('Path traversal detected');
+        }, inferErrorStatus));
+        const res = await request(app).get('/test');
+        expect(res.status).toBe(403);
+    });
+    it('handles non-Error thrown values', async () => {
+        const app = createApp(catchRoute(() => {
+            // eslint-disable-next-line no-throw-literal
+            throw 'raw string error';
+        }));
+        const res = await request(app).get('/test');
+        expect(res.status).toBe(500);
+        expect(res.body).toEqual({ success: false, error: 'raw string error' });
+    });
+});

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++;
         }

package/dist/server/server/validator.js

@@ -0,0 +1,230 @@
+/**
+ * Validation module for the Orbital Command primitive system.
+ *
+ * Checks cross-references between manifest, settings.local.json,
+ * workflow.json, and files on disk. Ensures internal consistency.
+ */
+import fs from 'fs';
+import path from 'path';
+import { loadManifest } from './manifest.js';
+import { validateHookPaths } from './settings-sync.js';
+/**
+ * Run all validation checks on a project. Returns a structured report.
+ */
+export function validate(projectRoot, packageVersion) {
+    const results = [];
+    const claudeDir = path.join(projectRoot, '.claude');
+    // 1. Check manifest exists
+    const manifest = loadManifest(projectRoot);
+    if (!manifest) {
+        results.push({
+            severity: 'warning',
+            message: 'No orbital-manifest.json found — run `orbital update` to create one',
+        });
+        // Can't do further manifest checks without a manifest
+        return buildReport(results);
+    }
+    // 2. Manifest file existence — every template file should exist on disk
+    for (const [relPath, record] of Object.entries(manifest.files)) {
+        const absPath = path.join(claudeDir, relPath);
+        if (!fs.existsSync(absPath)) {
+            results.push({
+                severity: 'error',
+                message: 'Manifest references missing file',
+                file: relPath,
+                detail: `Origin: ${record.origin}, Status: ${record.status}`,
+            });
+        }
+    }
+    // 3. Untracked files — files on disk not in manifest
+    for (const dir of ['hooks', 'skills', 'agents']) {
+        const dirPath = path.join(claudeDir, dir);
+        if (!fs.existsSync(dirPath))
+            continue;
+        walkDir(dirPath, dir, (relPath) => {
+            if (!manifest.files[relPath]) {
+                results.push({
+                    severity: 'warning',
+                    message: 'Untracked file in managed directory',
+                    file: relPath,
+                    detail: 'Not in manifest — may be orphaned or user-created',
+                });
+            }
+        });
+    }
+    // 4. Settings hook file existence
+    const settingsPath = path.join(claudeDir, 'settings.local.json');
+    const brokenHooks = validateHookPaths(settingsPath, projectRoot);
+    for (const command of brokenHooks) {
+        results.push({
+            severity: 'error',
+            message: 'Settings hook references missing file',
+            detail: command,
+        });
+    }
+    // 5. Workflow integrity
+    const workflowPath = path.join(claudeDir, 'config', 'workflow.json');
+    if (fs.existsSync(workflowPath)) {
+        validateWorkflow(workflowPath, claudeDir, results);
+    }
+    // 6. Config schema check (basic — just verify it parses)
+    const configPath = path.join(claudeDir, 'orbital.config.json');
+    if (fs.existsSync(configPath)) {
+        try {
+            JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        }
+        catch {
+            results.push({
+                severity: 'error',
+                message: 'orbital.config.json is malformed JSON',
+                file: 'orbital.config.json',
+            });
+        }
+    }
+    else {
+        results.push({
+            severity: 'warning',
+            message: 'orbital.config.json not found',
+        });
+    }
+    // 7. Version consistency
+    if (manifest.packageVersion !== packageVersion) {
+        results.push({
+            severity: 'warning',
+            message: 'Manifest version mismatch — run `orbital update`',
+            detail: `Manifest: ${manifest.packageVersion}, Package: ${packageVersion}`,
+        });
+    }
+    // 8. Generated artifacts exist
+    for (const artifact of manifest.generatedArtifacts) {
+        const artifactPath = path.join(claudeDir, artifact);
+        if (!fs.existsSync(artifactPath)) {
+            results.push({
+                severity: 'warning',
+                message: 'Generated artifact missing',
+                file: artifact,
+                detail: 'Will be regenerated on next update',
+            });
+        }
+    }
+    return buildReport(results);
+}
+/**
+ * Format a validation report for CLI output.
+ */
+export function formatValidationReport(report) {
+    const lines = [];
+    lines.push('Orbital Command — validation report\n');
+    if (report.results.length === 0) {
+        lines.push('  All checks passed.\n');
+        return lines.join('\n');
+    }
+    // Group by severity
+    const grouped = {
+        error: [],
+        warning: [],
+        info: [],
+    };
+    for (const r of report.results) {
+        grouped[r.severity].push(r);
+    }
+    for (const severity of ['error', 'warning', 'info']) {
+        const items = grouped[severity];
+        if (items.length === 0)
+            continue;
+        const label = severity === 'error' ? 'ERRORS' : severity === 'warning' ? 'WARNINGS' : 'INFO';
+        lines.push(`  ${label}:`);
+        for (const item of items) {
+            const file = item.file ? ` [${item.file}]` : '';
+            const detail = item.detail ? ` — ${item.detail}` : '';
+            lines.push(`    ${item.message}${file}${detail}`);
+        }
+        lines.push('');
+    }
+    lines.push(`  Summary: ${report.errors} errors, ${report.warnings} warnings, ${report.info} info`);
+    return lines.join('\n');
+}
+// ─── Internal Helpers ───────────────────────────────────────
+/** Recursively walk a directory, calling fn with relative paths. */
+function walkDir(dirPath, prefix, fn) {
+    if (!fs.existsSync(dirPath))
+        return;
+    for (const entry of fs.readdirSync(dirPath, { withFileTypes: true })) {
+        if (entry.name.startsWith('.'))
+            continue;
+        const absPath = path.join(dirPath, entry.name);
+        const relPath = `${prefix}/${entry.name}`;
+        // Follow symlinks: use stat() to check if target is a directory
+        const stat = fs.statSync(absPath);
+        if (stat.isDirectory()) {
+            walkDir(absPath, relPath, fn);
+        }
+        else {
+            fn(relPath);
+        }
+    }
+}
+/** Validate workflow.json hook targets and edge commands. */
+function validateWorkflow(workflowPath, claudeDir, results) {
+    let workflow;
+    try {
+        workflow = JSON.parse(fs.readFileSync(workflowPath, 'utf-8'));
+    }
+    catch {
+        results.push({
+            severity: 'error',
+            message: 'workflow.json is malformed JSON',
+            file: 'config/workflow.json',
+        });
+        return;
+    }
+    // Check hook targets
+    const hooks = workflow.hooks;
+    if (Array.isArray(hooks)) {
+        for (const hook of hooks) {
+            if (!hook.target)
+                continue;
+            // Resolve hook target relative to project root (targets use .claude/ prefix)
+            const targetPath = path.resolve(path.dirname(claudeDir), hook.target);
+            if (!fs.existsSync(targetPath)) {
+                results.push({
+                    severity: 'error',
+                    message: 'Workflow hook references missing script',
+                    file: 'config/workflow.json',
+                    detail: `Hook "${hook.id || 'unknown'}": ${hook.target}`,
+                });
+            }
+        }
+    }
+    // Check edge commands reference existing skills
+    const edges = workflow.edges;
+    if (Array.isArray(edges)) {
+        for (const edge of edges) {
+            if (!edge.command)
+                continue;
+            // Extract skill name from command like "/skill-name {id}"
+            const match = edge.command.match(/^\/([a-z-]+)/);
+            if (!match)
+                continue;
+            const skillName = match[1];
+            const skillPath = path.join(claudeDir, 'skills', skillName, 'SKILL.md');
+            if (!fs.existsSync(skillPath)) {
+                results.push({
+                    severity: 'warning',
+                    message: 'Workflow edge references unknown skill',
+                    file: 'config/workflow.json',
+                    detail: `Edge "${edge.from}" → "${edge.to}": ${edge.command}`,
+                });
+            }
+        }
+    }
+}
+/** Build a report with counts from a list of results. */
+function buildReport(results) {
+    return {
+        results,
+        errors: results.filter(r => r.severity === 'error').length,
+        warnings: results.filter(r => r.severity === 'warning').length,
+        info: results.filter(r => r.severity === 'info').length,
+    };
+}

package/dist/server/server/watchers/event-watcher.js

@@ -5,6 +5,7 @@ import { parseEventFile } from '../parsers/event-parser.js';
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('event');
 const ARCHIVE_DIR_NAME = 'processed';
+const processingFiles = new Set();
 /**
  * Watch .claude/orbital-events/ for new JSON event files.
  * On startup, processes any existing unprocessed events.
@@ -59,23 +60,37 @@ function processExistingEvents(eventsDir, eventService, archiveDir) {
     }
 }
 function processEventFile(filePath, eventService, archiveDir) {
-    const event = parseEventFile(filePath);
-    if (!event)
+    if (processingFiles.has(filePath))
         return;
-    eventService.ingest(event);
-    // Move to archive
-    const fileName = path.basename(filePath);
+    processingFiles.add(filePath);
     try {
-        fs.renameSync(filePath, path.join(archiveDir, fileName));
-    }
-    catch (err) {
-        log.warn('Failed to archive event file', { file: filePath, error: err.message });
-        // If rename fails (cross-device), just delete the source
+        const event = parseEventFile(filePath);
+        if (!event)
+            return;
+        eventService.ingest(event);
+        // Move to archive
+        const fileName = path.basename(filePath);
         try {
-            fs.unlinkSync(filePath);
+            fs.renameSync(filePath, path.join(archiveDir, fileName));
         }
-        catch (unlinkErr) {
-            log.warn('Failed to delete event file', { file: filePath, error: unlinkErr.message });
+        catch (err) {
+            const code = err.code;
+            if (code === 'ENOENT')
+                return; // Already archived by concurrent handler
+            log.warn('Failed to archive event file', { file: filePath, error: err.message });
+            // If rename fails (cross-device), just delete the source
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch (unlinkErr) {
+                const unlinkCode = unlinkErr.code;
+                if (unlinkCode !== 'ENOENT') {
+                    log.warn('Failed to delete event file', { file: filePath, error: unlinkErr.message });
+                }
+            }
         }
     }
+    finally {
+        processingFiles.delete(filePath);
+    }
 }