@agentdeck/bridge 0.2.2 → 0.2.3

package/dist/cli.js

@@ -1,17 +1,63 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import { writeFileSync, unlinkSync, existsSync } from 'fs';
+import { writeFileSync, unlinkSync, existsSync, realpathSync } from 'fs';
 import { homedir } from 'os';
-import { join } from 'path';
-import { execSync, spawn } from 'child_process';
+import { dirname, join } from 'path';
+import { execFileSync, execSync, spawn } from 'child_process';
 import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
+import { request } from 'http';
 import { BRIDGE_WS_PORT } from './types.js';
+import { TASK_NAME, installWindowsTask, taskExists, runWindowsTask, endWindowsTask, deleteWindowsTask, } from './windows-service.js';
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
 function log(msg) {
     process.stderr.write(msg + '\n');
 }
+function formatBytes(value) {
+    const bytes = typeof value === 'number' && Number.isFinite(value) ? value : 0;
+    if (bytes >= 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+    if (bytes >= 1024)
+        return `${Math.round(bytes / 1024)}KB`;
+    return `${bytes}B`;
+}
+function postJsonWithTimeout(urlString, body, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const payload = JSON.stringify(body);
+        const url = new URL(urlString);
+        const req = request({
+            hostname: url.hostname,
+            port: url.port,
+            path: `${url.pathname}${url.search}`,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(payload),
+            },
+        }, (res) => {
+            const chunks = [];
+            res.on('data', (chunk) => {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            });
+            res.on('end', () => {
+                const text = Buffer.concat(chunks).toString('utf8');
+                try {
+                    resolve({ statusCode: res.statusCode ?? 0, body: JSON.parse(text) });
+                }
+                catch (err) {
+                    reject(new Error(`Invalid JSON response: ${err instanceof Error ? err.message : String(err)}`));
+                }
+            });
+        });
+        req.setTimeout(timeoutMs, () => {
+            req.destroy(new Error(`Request timed out after ${Math.round(timeoutMs / 1000)}s`));
+        });
+        req.on('error', reject);
+        req.write(payload);
+        req.end();
+    });
+}
 // ===== LaunchAgent plist =====
 const PLIST_LABEL = 'dev.agentdeck.daemon';
 const PLIST_PATH = join(homedir(), 'Library', 'LaunchAgents', `${PLIST_LABEL}.plist`);
@@ -65,13 +111,85 @@ async function stopDaemon(port) {
     const info = readDaemonInfo();
     const targetPort = info?.httpPort ?? info?.port ?? findDaemonPort() ?? port;
     try {
-        await fetch(`http://127.0.0.1:${targetPort}/shutdown`, { method: 'POST' });
+        await fetch(`http://127.0.0.1:${targetPort}/shutdown`, {
+            method: 'POST',
+            signal: AbortSignal.timeout(2000),
+        });
         log('Shutdown signal sent');
     }
     catch {
         log('Daemon is not running');
     }
 }
+async function isDaemonPort(port) {
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/health`, {
+            signal: AbortSignal.timeout(1000),
+        });
+        if (!res.ok)
+            return false;
+        const data = await res.json();
+        return data.mode === 'daemon' || data.agentType === 'daemon';
+    }
+    catch {
+        return false;
+    }
+}
+function resolveTimeboxSyncPaths() {
+    const distPath = dirname(fileURLToPath(import.meta.url));
+    const projectRoot = join(distPath, '..', '..');
+    const timeboxDir = join(projectRoot, 'bridge', 'src', 'timebox');
+    return {
+        python: join(projectRoot, '.venv', 'bin', 'python'),
+        bleScript: join(timeboxDir, 'sync_ble.py'),
+        scanScript: join(timeboxDir, 'scan_ble.py'),
+    };
+}
+function projectRootPath() {
+    return join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+}
+const ESP32_OTA_BOARDS = [
+    { board: 'inkdeck', env: 'inkdeck', aliases: [] },
+    { board: 'ulanzi_tc001', env: 'led8x32', aliases: ['led8x32'] },
+    { board: 'ttgo_t_display', env: 'ttgo', aliases: ['ttgo'] },
+    { board: 'round_amoled', env: 'amoled', aliases: ['amoled'] },
+    { board: 'ips_35', env: 'ips35', aliases: ['ips35'] },
+    { board: '86box', env: 'box_86', aliases: ['box_86', 'box_40'] },
+    { board: 'ips_10', env: 'ips10', aliases: ['ips10', 'ips_101'] },
+];
+// alias/board/env-key → { env, board }. Built from the SSOT above.
+export const ESP32_OTA_BY_TARGET = {};
+for (const b of ESP32_OTA_BOARDS) {
+    for (const key of [b.board, ...b.aliases]) {
+        ESP32_OTA_BY_TARGET[key] = { env: b.env, board: b.board };
+    }
+}
+/**
+ * Resolve an esp32-ota `target` (alias, canonical board string, or an IP) to the
+ * canonical `device_info.board` string the daemon matches against. Unknown
+ * targets (e.g. a raw IP or one-off board) pass through unchanged so IP-based
+ * and future targeting still works. Exported for testing.
+ */
+export function resolveEsp32OtaDaemonTarget(target) {
+    return ESP32_OTA_BY_TARGET[target]?.board ?? target;
+}
+function resolveEsp32FirmwarePath(target, envOpt, firmwareOpt) {
+    if (firmwareOpt)
+        return realpathSync(firmwareOpt);
+    const env = envOpt || ESP32_OTA_BY_TARGET[target]?.env || target;
+    const path = join(projectRootPath(), 'esp32', '.pio', 'build', env, 'firmware.bin');
+    if (!existsSync(path)) {
+        throw new Error(`Firmware not found: ${path}. Build it first with: /opt/homebrew/bin/pio run -e ${env}`);
+    }
+    return path;
+}
+function platformioBin() {
+    if (process.env.PLATFORMIO)
+        return process.env.PLATFORMIO;
+    if (existsSync('/opt/homebrew/bin/pio'))
+        return '/opt/homebrew/bin/pio';
+    return 'pio';
+}
 // ===== Program =====
 const program = new Command();
 program
@@ -101,12 +219,12 @@ program
         noUpdateCheck: opts.updateCheck === false,
         postit: opts.postit !== false,
         wakeWord: !!opts.wakeWord,
-        modules: opts.local ? { mdns: false, adb: false, serial: false, pixoo: false, d200h: false } : {
+        modules: opts.local ? { mdns: false, adb: false, serial: false, pixoo: false, timebox: false } : {
             mdns: false, // daemon-only — session bridges never advertise mDNS
             adb: opts.adb !== false ? 'auto' : false,
             serial: false, // daemon-only — session bridges never talk to ESP32
             pixoo: false, // daemon-only — session bridges never talk to Pixoo
-            d200h: false, // daemon-only — session bridges never talk to D200H
+            timebox: false, // daemon-only — session bridges never talk to Timebox
         },
     });
 });
@@ -119,7 +237,32 @@ program
     .option('--local', 'Disable all device modules (WS only)')
     .option('--no-adb', 'Disable ADB reverse setup')
     .option('--no-postit', 'Disable terminal tab title updates')
+    .option('--no-codex-hooks', 'Skip ~/.codex/config.toml hook install')
     .action(async (opts) => {
+    // Install Codex lifecycle hooks before starting the session so the
+    // first prompt's UserPromptSubmit / Stop events reach the daemon.
+    // Idempotent: re-running with the same daemon port is a no-op.
+    if (opts.codexHooks !== false) {
+        try {
+            const { installCodexHooksIfNeeded } = await import('@agentdeck/hooks');
+            const result = installCodexHooksIfNeeded();
+            if (result.installed) {
+                log('Codex lifecycle hooks ready in ~/.codex/config.toml');
+                if (result.warning)
+                    log(`Codex hooks degraded: ${result.warning}`);
+            }
+            else if (result.reason) {
+                log(`Codex hooks skipped: ${result.reason}`);
+            }
+        }
+        catch (err) {
+            log(`Codex hooks unavailable: ${String(err)}`);
+            // PTY parser fallback still works without lifecycle hooks.
+        }
+    }
+    else {
+        log('Codex hooks skipped: --no-codex-hooks');
+    }
     const { startSession } = await import('./index.js');
     await startSession({
         agentType: 'codex-cli',
@@ -127,12 +270,12 @@ program
         command: opts.command,
         debug: opts.debug,
         postit: opts.postit !== false,
-        modules: opts.local ? { mdns: false, adb: false, serial: false, pixoo: false, d200h: false } : {
+        modules: opts.local ? { mdns: false, adb: false, serial: false, pixoo: false, timebox: false } : {
             mdns: false, // daemon-only
             adb: opts.adb !== false ? 'auto' : false,
             serial: false, // daemon-only
             pixoo: false, // daemon-only
-            d200h: false, // daemon-only
+            timebox: false, // daemon-only
         },
     });
 });
@@ -145,7 +288,31 @@ program
     .option('--local', 'Disable all device modules (WS only)')
     .option('--no-adb', 'Disable ADB reverse setup')
     .option('--no-postit', 'Disable terminal tab title updates')
+    .option('--no-opencode-hooks', 'Skip OpenCode observer plugin install')
     .action(async (opts) => {
+    // Install the OpenCode observer plugin so standalone `opencode` runs
+    // (outside this managed session) also reach the daemon timeline. The
+    // plugin self-disables inside managed PTYs via AGENTDECK_PORT, so this
+    // session is unaffected. Idempotent content-compare write.
+    if (opts.opencodeHooks !== false) {
+        try {
+            const { installOpenCodeHooksIfNeeded, opencodePluginPath } = await import('@agentdeck/hooks');
+            const result = installOpenCodeHooksIfNeeded();
+            if (result.installed) {
+                log(`OpenCode observer plugin ready at ${opencodePluginPath()}`);
+            }
+            else if (result.reason) {
+                log(`OpenCode observer plugin skipped: ${result.reason}`);
+            }
+        }
+        catch (err) {
+            log(`OpenCode observer plugin unavailable: ${String(err)}`);
+            // Managed SSE bridge works without the plugin.
+        }
+    }
+    else {
+        log('OpenCode observer plugin skipped: --no-opencode-hooks');
+    }
     const { startSession } = await import('./index.js');
     await startSession({
         agentType: 'opencode',
@@ -153,12 +320,12 @@ program
         command: opts.command,
         debug: opts.debug,
         postit: opts.postit !== false,
-        modules: opts.local ? { mdns: false, adb: false, serial: false, pixoo: false, d200h: false } : {
+        modules: opts.local ? { mdns: false, adb: false, serial: false, pixoo: false, timebox: false } : {
             mdns: false,
             adb: opts.adb !== false ? 'auto' : false,
             serial: false,
             pixoo: false,
-            d200h: false,
+            timebox: false,
         },
     });
 });
@@ -177,9 +344,15 @@ program
         agentType: 'monitor',
         port,
         debug: opts.debug,
-        modules: opts.local ? { mdns: false, adb: false, serial: false, pixoo: false, d200h: false } : undefined,
+        modules: opts.local ? { mdns: false, adb: false, serial: false, pixoo: false, timebox: false } : undefined,
     });
 });
+// The worktree-compare feature ("cockpit") was extracted into its own
+// standalone tool, Worktree Cockpit (`wtcp`):
+// https://github.com/puritysb/worktree-cockpit . It no longer ships with
+// AgentDeck. AgentDeck still exposes
+// the on-device Apple Intelligence helper via the daemon `/generate` endpoint,
+// which wtcp can optionally use for branch naming.
 // ===== Daemon commands =====
 const daemon = program.command('daemon').description('Manage monitoring daemon');
 daemon
@@ -190,20 +363,65 @@ daemon
     .option('-f, --foreground', 'Run in foreground (default: background fork)')
     .option('--wake-word', 'Enable wake word voice assistant ("오픈클로")')
     .action(async (opts) => {
-    const { findExistingDaemon, readDaemonInfo } = await import('./session-registry.js');
+    const { findExistingDaemon, probeDaemonHealth, readDaemonInfo, removeDaemonInfo, removeDaemonSession, requestDaemonStandDown, requestDaemonShutdown, waitForDaemonExit } = await import('./session-registry.js');
+    // Reverse two-tier upgrade path: the macOS app may already own the canonical
+    // port with its in-process Swift daemon (Tier 1 — limited: no ADB devices,
+    // no subscription usage, …). A plain "already running → exit" would strand
+    // the user on Tier 1. Instead, if the incumbent identifies as a Swift
+    // daemon, ask it to STAND DOWN (demote to client, app keeps running) so this
+    // CLI daemon can take over with the full feature set, then wait for the port
+    // to clear before binding. A real Node daemon on the port still means
+    // "already running".
+    const targetPort = opts.port ? parseInt(String(opts.port), 10) : BRIDGE_WS_PORT;
+    const incumbent = await probeDaemonHealth(targetPort);
+    if (incumbent?.mode === 'daemon') {
+        if (incumbent.isSwift) {
+            log(`AgentDeck app's in-process daemon holds port ${targetPort} — requesting stand-down to take over with the full CLI feature set…`);
+            // Prefer /stand-down (clean demote: the app stays running as a client).
+            // Fall back to /shutdown for older app builds that predate the endpoint.
+            let acked = await requestDaemonStandDown(targetPort);
+            if (!acked) {
+                await requestDaemonShutdown(targetPort);
+                acked = true; // shutdown is best-effort (no ack body); rely on the exit wait
+            }
+            if (acked && await waitForDaemonExit(targetPort, 12000)) {
+                log(`App daemon yielded port ${targetPort}. Starting CLI daemon…`);
+                // fall through — port is clear, proceed to bind below
+            }
+            else {
+                log(`The AgentDeck app did not yield port ${targetPort} in time. Quit the app and retry 'agentdeck daemon start', or start on a different port with -p.`);
+                process.exit(1);
+            }
+        }
+        else {
+            log(`Daemon already running on port ${targetPort}. Use 'agentdeck daemon stop' first.`);
+            process.exit(0);
+        }
+    }
     const daemonInfo = readDaemonInfo();
     if (daemonInfo) {
-        log(`Daemon already running on port ${daemonInfo.port} (PID ${daemonInfo.pid}). Use 'agentdeck daemon stop' first.`);
-        process.exit(0);
+        const probePort = daemonInfo.httpPort ?? daemonInfo.port;
+        const health = await probeDaemonHealth(probePort);
+        if (health?.mode === 'daemon') {
+            log(`Daemon already running on port ${daemonInfo.port} (PID ${daemonInfo.pid}). Use 'agentdeck daemon stop' first.`);
+            process.exit(0);
+        }
+        log(`Ignoring stale daemon entry on port ${daemonInfo.port} (PID ${daemonInfo.pid}; /health did not respond).`);
+        removeDaemonInfo();
     }
     const existing = findExistingDaemon();
     if (existing) {
-        log(`Daemon already running on port ${existing.port} (PID ${existing.pid}). Use 'agentdeck daemon stop' first.`);
-        process.exit(0);
+        const health = await probeDaemonHealth(existing.port);
+        if (health?.mode === 'daemon') {
+            log(`Daemon already running on port ${existing.port} (PID ${existing.pid}). Use 'agentdeck daemon stop' first.`);
+            process.exit(0);
+        }
+        log(`Ignoring stale daemon session on port ${existing.port} (PID ${existing.pid}; /health did not respond).`);
+        removeDaemonSession(existing);
     }
     // Background fork unless --foreground
     if (!opts.foreground) {
-        const { openSync } = await import('fs');
+        const { openSync, statSync, renameSync } = await import('fs');
         const logDir = join(homedir(), '.agentdeck');
         const scriptPath = fileURLToPath(import.meta.url);
         const args = [scriptPath, 'daemon', 'start', '--foreground'];
@@ -214,8 +432,22 @@ daemon
         if (opts.wakeWord)
             args.push('--wake-word');
         // Use log files instead of 'ignore' — preserves device access (mic, etc.)
-        const out = openSync(join(logDir, 'daemon-stdout.log'), 'w');
-        const err = openSync(join(logDir, 'daemon-stderr.log'), 'w');
+        // Append (never truncate) so multi-day history survives restarts —
+        // overnight device incidents can only be correlated against logs that
+        // are still there in the morning. Rotate once past 5MB instead.
+        const openDaemonLog = (name) => {
+            const path = join(logDir, name);
+            try {
+                if (statSync(path).size > 5 * 1024 * 1024)
+                    renameSync(path, `${path}.1`);
+            }
+            catch {
+                /* first run — no log yet */
+            }
+            return openSync(path, 'a');
+        };
+        const out = openDaemonLog('daemon-stdout.log');
+        const err = openDaemonLog('daemon-stderr.log');
         const child = spawn(process.execPath, args, {
             detached: true,
             stdio: ['ignore', out, err],
@@ -267,7 +499,7 @@ daemon
     .option('-p, --port <port>', 'Server port', String(BRIDGE_WS_PORT))
     .action(async (opts) => {
     const port = parseInt(opts.port, 10);
-    const { listActive, readDaemonInfo } = await import('./session-registry.js');
+    const { listActive, readDaemonInfo, removeDaemonInfo, removeDaemonSession } = await import('./session-registry.js');
     const info = readDaemonInfo();
     const sessions = listActive();
     const d = sessions.find(s => s.agentType === 'daemon');
@@ -278,14 +510,70 @@ daemon
         log(`Daemon status (port ${targetPort}): ${JSON.stringify(data, null, 2)}`);
     }
     catch {
+        if (info)
+            removeDaemonInfo();
+        if (d)
+            removeDaemonSession(d);
         log('Daemon is not running');
         process.exit(1);
     }
 });
 daemon
     .command('install')
-    .description('Install macOS LaunchAgent for auto-start')
-    .action(() => {
+    .description('Install daemon auto-start (LaunchAgent on macOS, Scheduled Task on Windows)')
+    .action(async () => {
+    if (process.platform === 'win32') {
+        try {
+            installWindowsTask();
+            log(`Scheduled task '${TASK_NAME}' registered. Daemon will auto-start on logon.`);
+        }
+        catch (e) {
+            const detail = e.stderr?.toString().trim() || e.message;
+            log('Failed to register the AgentDeck scheduled task.');
+            if (detail)
+                log(detail);
+            log('You can still run the daemon manually with: agentdeck daemon start');
+            log('(or add a shortcut to shell:startup to autostart it yourself).');
+            process.exit(1);
+        }
+        // Start it now so the user does not have to log out/in (the singleton
+        // guard makes a double-start a safe no-op).
+        try {
+            runWindowsTask();
+            log('Daemon started.');
+        }
+        catch {
+            log('Task registered; immediate start failed — it will start on next logon.');
+        }
+        // Install Codex lifecycle hooks for parity with the macOS install path.
+        try {
+            const { installCodexHooksIfNeeded } = await import('@agentdeck/hooks');
+            const result = installCodexHooksIfNeeded();
+            if (result.installed) {
+                log('Codex lifecycle hooks installed in ~/.codex/config.toml');
+                if (result.warning)
+                    log(`Codex hooks degraded: ${result.warning}`);
+            }
+            else if (result.reason) {
+                log(`Codex hooks skipped: ${result.reason}`);
+            }
+        }
+        catch { /* hooks package not built yet — task install still succeeds */ }
+        // OpenCode observer plugin — standalone `opencode` runs report to the
+        // daemon timeline the same way direct `codex` runs do.
+        try {
+            const { installOpenCodeHooksIfNeeded } = await import('@agentdeck/hooks');
+            const result = installOpenCodeHooksIfNeeded();
+            if (result.installed) {
+                log('OpenCode observer plugin installed.');
+            }
+            else if (result.reason) {
+                log(`OpenCode observer plugin skipped: ${result.reason}`);
+            }
+        }
+        catch { /* hooks package not built yet — task install still succeeds */ }
+        process.exit(0);
+    }
     if (process.platform !== 'darwin') {
         log('LaunchAgent is macOS-only');
         process.exit(1);
@@ -299,11 +587,61 @@ daemon
     catch { }
     execSync(`launchctl load "${PLIST_PATH}"`);
     log('LaunchAgent loaded. Daemon will auto-start on login.');
+    // Install Codex lifecycle hooks parallel to the LaunchAgent install
+    // so the daemon hub gets codex_* events as soon as Codex CLI runs.
+    try {
+        const { installCodexHooksIfNeeded } = await import('@agentdeck/hooks');
+        const result = installCodexHooksIfNeeded();
+        if (result.installed) {
+            log('Codex lifecycle hooks installed in ~/.codex/config.toml');
+        }
+        else if (result.reason) {
+            log(`Codex hooks skipped: ${result.reason}`);
+        }
+    }
+    catch { /* hooks package not built yet — daemon install still succeeds */ }
+    // OpenCode observer plugin — standalone `opencode` runs report to the
+    // daemon hub as opencode_* events, same pipeline as codex_*.
+    try {
+        const { installOpenCodeHooksIfNeeded, opencodePluginPath } = await import('@agentdeck/hooks');
+        const result = installOpenCodeHooksIfNeeded();
+        if (result.installed) {
+            log(`OpenCode observer plugin installed at ${opencodePluginPath()}`);
+        }
+        else if (result.reason) {
+            log(`OpenCode observer plugin skipped: ${result.reason}`);
+        }
+    }
+    catch { /* hooks package not built yet — daemon install still succeeds */ }
 });
 daemon
     .command('uninstall')
-    .description('Remove macOS LaunchAgent')
-    .action(() => {
+    .description('Remove daemon auto-start (LaunchAgent on macOS, Scheduled Task on Windows)')
+    .action(async () => {
+    if (process.platform === 'win32') {
+        if (!taskExists()) {
+            log(`Scheduled task '${TASK_NAME}' is not installed.`);
+            process.exit(0);
+        }
+        // Graceful daemon shutdown first, then stop + delete the task.
+        await stopDaemon(BRIDGE_WS_PORT);
+        try {
+            endWindowsTask();
+        }
+        catch { /* not running */ }
+        try {
+            deleteWindowsTask();
+            log(`Scheduled task '${TASK_NAME}' removed.`);
+        }
+        catch (e) {
+            const detail = e.stderr?.toString().trim() || e.message;
+            log('Failed to remove the scheduled task.');
+            if (detail)
+                log(detail);
+            process.exit(1);
+        }
+        process.exit(0);
+    }
     if (!existsSync(PLIST_PATH)) {
         log('LaunchAgent not installed');
         return;
@@ -358,8 +696,15 @@ program
     }
     else {
         try {
-            await fetch(`http://127.0.0.1:${port}/hooks/shutdown`, { method: 'POST' });
-            log('Shutdown signal sent');
+            const daemonPort = await isDaemonPort(port);
+            const url = daemonPort
+                ? `http://127.0.0.1:${port}/shutdown`
+                : `http://127.0.0.1:${port}/hooks/shutdown`;
+            await fetch(url, {
+                method: 'POST',
+                signal: AbortSignal.timeout(2000),
+            });
+            log(daemonPort ? 'Daemon shutdown signal sent' : 'Shutdown signal sent');
         }
         catch {
             log('Session is not running');
@@ -369,10 +714,14 @@ program
 // ===== Device commands =====
 program
     .command('devices')
-    .description('Show connected devices (WebSocket, ESP32, Pixoo, ADB)')
-    .option('-p, --port <port>', 'Bridge server port', String(BRIDGE_WS_PORT))
+    .description('Show connected devices (WebSocket, ESP32, Pixoo, Timebox, ADB)')
+    .option('-p, --port <port>', 'Bridge server port')
     .action(async (opts) => {
-    const port = parseInt(opts.port, 10);
+    const { readDaemonInfo, findDaemonPort } = await import('./session-registry.js');
+    const info = readDaemonInfo();
+    const port = opts.port != null
+        ? parseInt(opts.port, 10)
+        : (info?.httpPort ?? info?.port ?? findDaemonPort() ?? BRIDGE_WS_PORT);
     try {
         const res = await fetch(`http://127.0.0.1:${port}/devices`, {
             signal: AbortSignal.timeout(2000),
@@ -386,15 +735,51 @@ program
                 total += d.count;
             }
             else if ((d.type === 'esp32' || d.type === 'esp32_serial') && (d.count || d.connections)) {
-                // Node daemon: { count, ports }, Swift daemon: { connections: [{ port, connected, deviceInfo }] }
+                // Node daemon: { count, ports, devices }, Swift daemon: { connections: [{ port, connected, deviceInfo }] }
                 const count = d.count ?? d.connections?.filter((c) => c.connected).length ?? 0;
                 const ports = d.ports ?? d.connections?.map((c) => c.port) ?? [];
+                // Per-device build identity, so a stale flash is distinguishable from the latest.
+                const devices = d.devices ?? d.connections?.filter((c) => c.connected).map((c) => ({ port: c.port, ...c.deviceInfo })) ?? [];
                 if (count > 0) {
-                    const portInfo = ports.length ? ` (${ports.join(', ')})` : '';
-                    lines.push(`  ESP32        ${count} serial${portInfo}`);
+                    if (devices.length) {
+                        lines.push(`  ESP32        ${count} serial`);
+                        for (const dev of devices) {
+                            const ver = dev.version ? ` v${dev.version}` : '';
+                            const hash = dev.buildHash ? ` (${dev.buildHash})` : '';
+                            const board = dev.board ?? 'esp32';
+                            const ota = dev.otaSupported === true
+                                ? ` OTA ${formatBytes(dev.otaSlotSize)}`
+                                : dev.otaReason ? ` OTA no:${dev.otaReason}` : '';
+                            lines.push(`                 ${board}${ver}${hash}${ota} @ ${dev.port}`);
+                        }
+                    }
+                    else {
+                        const portInfo = ports.length ? ` (${ports.join(', ')})` : '';
+                        lines.push(`  ESP32        ${count} serial${portInfo}`);
+                    }
                     total += count;
                 }
             }
+            else if (d.type === 'esp32-wifi') {
+                const devices = (d.devices ?? []);
+                if (devices.length) {
+                    lines.push(`  ESP32 WiFi   ${devices.length} client${devices.length !== 1 ? 's' : ''}`);
+                    for (const dev of devices) {
+                        const ver = dev.version ? ` v${dev.version}` : '';
+                        const hash = dev.buildHash ? ` (${dev.buildHash})` : '';
+                        const board = dev.board ?? 'esp32';
+                        const ota = dev.otaSupported === true
+                            ? ` OTA ${formatBytes(dev.otaSlotSize)}`
+                            : dev.otaReason ? ` OTA no:${dev.otaReason}` : '';
+                        const stale = dev.stale ? ' stale' : '';
+                        // Single-path: a board also live on USB serial is driven over
+                        // serial; its WiFi link is a hot standby (no duplicate traffic).
+                        const transport = dev.serialActive ? ' [serial-active · wifi standby]' : '';
+                        lines.push(`                 ${board}${ver}${hash}${ota}${stale}${transport} @ ${dev.ip ?? 'wifi'}`);
+                    }
+                    total += devices.length;
+                }
+            }
             else if (d.type === 'pixoo') {
                 // Node daemon: { details: [...] }, Swift daemon: { deviceIps: [...] }
                 if (d.details) {
@@ -418,6 +803,43 @@ program
                     }
                 }
             }
+            else if (d.type === 'timebox') {
+                // Node daemon: { devices: [{address, name, brightness}] }, Swift
+                // daemon: { configuredDeviceCount, connected, deviceName, statusReason }.
+                if (Array.isArray(d.devices)) {
+                    for (const tb of d.devices) {
+                        const brightnessInfo = tb.brightness !== undefined ? ` brightness=${tb.brightness}%` : '';
+                        lines.push(`  Timebox     ${tb.address} (${tb.name || 'Timebox Mini Light'})${brightnessInfo}`);
+                        total++;
+                    }
+                }
+                else if ((d.configuredDeviceCount ?? 0) > 0) {
+                    const status = d.connected ? '✓' : `⚠ ${d.statusReason ?? 'not connected'}`;
+                    lines.push(`  Timebox      ${d.deviceName ?? 'Timebox Mini'} ${status}`);
+                    total++;
+                }
+            }
+            else if (d.type === 'idotmatrix') {
+                // Node daemon: { devices: [{address, name}] }, Swift daemon:
+                // { configuredDeviceCount, connected, deviceName, statusReason }.
+                if (Array.isArray(d.devices)) {
+                    for (const dm of d.devices) {
+                        lines.push(`  iDotMatrix   ${dm.address} (${dm.name || 'iDotMatrix'})`);
+                        total++;
+                    }
+                }
+                else if ((d.configuredDeviceCount ?? 0) > 0) {
+                    const status = d.connected ? '✓' : `⚠ ${d.statusReason ?? 'not connected'}`;
+                    lines.push(`  iDotMatrix   ${d.deviceName ?? 'iDotMatrix'} ${status}`);
+                    total++;
+                }
+            }
+            else if (d.type === 'tui') {
+                for (const t of (d.devices ?? [])) {
+                    lines.push(`  TUI          ${t.name ?? 'terminal'} (agentdeck dashboard)`);
+                    total++;
+                }
+            }
             else if (d.type === 'adb') {
                 const count = d.count ?? d.devices?.length ?? 0;
                 if (count > 0) {
@@ -426,8 +848,7 @@ program
                 }
             }
             else if (d.type === 'd200h' && d.connected) {
-                const writeInfo = d.writeOK != null ? ` (writes: ${d.writeOK} ok, ${d.writeFail} fail)` : '';
-                lines.push(`  D200H        HID connected${writeInfo}`);
+                lines.push(`  D200H        Ulanzi Studio connected (via WebSocket)`);
                 total++;
             }
         }
@@ -442,11 +863,17 @@ program
     }
     catch {
         const { loadPixooDevices } = await import('./pixoo/pixoo-settings.js');
+        const { loadTimeboxDevices } = await import('./timebox/timebox-settings.js');
         const pixoo = loadPixooDevices();
-        if (pixoo.length > 0) {
-            log('Bridge is not running.\nConfigured Pixoo devices:');
+        const timebox = loadTimeboxDevices();
+        if (pixoo.length > 0 || timebox.length > 0) {
+            log('Bridge is not running.\nConfigured devices:');
             for (const d of pixoo) {
-                log(`  ${d.ip} (${d.name || 'Pixoo64'})`);
+                log(`  Pixoo64     ${d.ip} (${d.name || 'Pixoo64'})`);
+            }
+            for (const d of timebox) {
+                const brightnessInfo = d.brightness !== undefined ? ` brightness=${d.brightness}%` : '';
+                log(`  Timebox     ${d.address} (${d.name || 'Timebox Mini Light'})${brightnessInfo}`);
             }
         }
         else {
@@ -454,6 +881,39 @@ program
         }
     }
 });
+program
+    .command('esp32-ota <target>')
+    .description('Upload built ESP32 firmware to a WiFi-connected AgentDeck ESP32')
+    .option('-p, --port <port>', 'Daemon port')
+    .option('-e, --env <env>', 'PlatformIO environment for default firmware path')
+    .option('-f, --firmware <path>', 'Firmware .bin path')
+    .option('--build', 'Build the PlatformIO environment before upload')
+    .action(async (target, opts) => {
+    const { readDaemonInfo, findDaemonPort } = await import('./session-registry.js');
+    const info = readDaemonInfo();
+    const port = opts.port != null
+        ? parseInt(opts.port, 10)
+        : (info?.httpPort ?? info?.port ?? findDaemonPort() ?? BRIDGE_WS_PORT);
+    const env = opts.env || ESP32_OTA_BY_TARGET[target]?.env || target;
+    if (opts.build) {
+        const pio = platformioBin();
+        log(`Building ${env} with ${pio}...`);
+        execFileSync(pio, ['run', '-e', env], {
+            cwd: join(projectRootPath(), 'esp32'),
+            stdio: 'inherit',
+        });
+    }
+    // Send the canonical board string, not the raw alias — the daemon matches
+    // `target` against device_info.board, so `ttgo` must become `ttgo_t_display`.
+    const daemonTarget = resolveEsp32OtaDaemonTarget(target);
+    const firmwarePath = resolveEsp32FirmwarePath(target, opts.env, opts.firmware);
+    log(`Uploading ${firmwarePath} to ${daemonTarget} via daemon :${port}...`);
+    const { statusCode, body } = await postJsonWithTimeout(`http://127.0.0.1:${port}/esp32/ota`, { target: daemonTarget, firmwarePath }, 15 * 60_000);
+    if (statusCode < 200 || statusCode >= 300 || body.ok === false) {
+        throw new Error(String(body.error ?? `HTTP ${statusCode}`));
+    }
+    log(`OTA complete: ${body.board ?? target} ${formatBytes(body.bytes)} in ${body.chunks} chunks`);
+});
 program
     .command('qr')
     .description('Show pairing URL and QR code')
@@ -496,7 +956,9 @@ program
     .option('-a, --analyze', 'Run AI analysis on the dump')
     .option('-t, --tail <lines>', 'Number of journal entries', '200')
     .action(async (opts) => {
-    const port = parseInt(opts.port, 10);
+    const { readDaemonInfo, findDaemonPort } = await import('./session-registry.js');
+    const info = readDaemonInfo();
+    const port = info?.httpPort ?? info?.port ?? findDaemonPort() ?? parseInt(opts.port, 10);
     const tail = parseInt(opts.tail, 10);
     try {
         const res = await fetch(`http://127.0.0.1:${port}/diag?tail=${tail}`);
@@ -525,6 +987,390 @@ program
         process.exit(1);
     }
 });
+// ===== Task control =====
+//
+// User-driven APME task boundary signal. Closes the currently-active task on
+// the daemon's APME collector via POST /task/close — same path the macOS
+// detail-pane "Mark task complete" button uses. Without this command, the
+// only ways to declare task completion are TodoWrite all-completed (Claude /
+// Codex / OpenCode) or /clear (also splits the run); OpenClaw users had no
+// manual gesture at all before idle_gap landed.
+const task = program.command('task').description('Manage APME task boundaries');
+async function postTaskClose(opts) {
+    const { readDaemonInfo, findDaemonPort } = await import('./session-registry.js');
+    const info = readDaemonInfo();
+    const port = info?.httpPort ?? info?.port ?? findDaemonPort();
+    if (!port) {
+        log('Daemon not running. Start it with `agentdeck daemon start`.');
+        process.exit(1);
+    }
+    const body = JSON.stringify({
+        signal: opts.signal,
+        ...(opts.outcome ? { outcome: opts.outcome } : {}),
+        ...(opts.sessionId ? { sessionId: opts.sessionId } : {}),
+    });
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/task/close`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body,
+        });
+        const json = await res.json().catch(() => ({}));
+        if (!res.ok) {
+            log(`Failed (${res.status}): ${JSON.stringify(json)}`);
+            process.exit(1);
+        }
+        if (json.closed) {
+            log(`Task closed (signal=${opts.signal}${opts.outcome ? `, outcome=${opts.outcome}` : ''})`);
+        }
+        else {
+            log('No active task to close.');
+        }
+    }
+    catch (err) {
+        log(`Request failed: ${String(err)}`);
+        process.exit(1);
+    }
+}
+task
+    .command('done')
+    .description('Mark the active task as complete (manual boundary signal)')
+    .option('-o, --outcome <v>', 'Outcome class: success | fail | partial | abandoned', 'success')
+    .option('-s, --session <id>', 'Target session id (defaults to active OpenClaw session)')
+    .action(async (opts) => {
+    await postTaskClose({ signal: 'manual', outcome: opts.outcome, sessionId: opts.session });
+});
+task
+    .command('cancel')
+    .description('Mark the active task as abandoned (shorthand for `task done --outcome abandoned`)')
+    .option('-s, --session <id>', 'Target session id (defaults to active OpenClaw session)')
+    .action(async (opts) => {
+    await postTaskClose({ signal: 'manual', outcome: 'abandoned', sessionId: opts.session });
+});
+// ===== iDotMatrix commands =====
+const idotmatrix = program.command('idotmatrix').description('Manage iDotMatrix BLE pixel display devices');
+idotmatrix
+    .command('scan')
+    .description('Discover iDotMatrix devices via BLE')
+    .action(async () => {
+    const { dirname } = await import('path');
+    const { fileURLToPath } = await import('url');
+    const { spawn } = await import('child_process');
+    const distPath = dirname(fileURLToPath(import.meta.url));
+    const projectRoot = join(distPath, '..', '..');
+    const venvPython = join(projectRoot, '.venv', 'bin', 'python');
+    const scanScript = join(projectRoot, 'bridge', 'src', 'idotmatrix', 'scan.py');
+    log('Scanning for BLE devices (5 seconds)...');
+    const py = spawn(venvPython, [scanScript]);
+    let stdoutData = '';
+    py.stdout.on('data', (data) => {
+        stdoutData += data.toString();
+    });
+    py.on('close', (code) => {
+        if (code !== 0) {
+            log('Failed to run scan script.');
+            process.exit(1);
+        }
+        try {
+            const devices = JSON.parse(stdoutData.trim());
+            if (devices.error) {
+                log(`Scan error: ${devices.error}`);
+                process.exit(1);
+            }
+            if (!Array.isArray(devices) || devices.length === 0) {
+                log('No BLE devices found.');
+                return;
+            }
+            log('\nFound devices:');
+            for (const d of devices) {
+                const prefix = d.is_idotmatrix ? '★ [iDotMatrix] ' : '  ';
+                log(`${prefix}${d.name} (${d.address})`);
+            }
+        }
+        catch (e) {
+            log(`Failed to parse scan output: ${stdoutData}`);
+        }
+    });
+});
+idotmatrix
+    .command('add <address>')
+    .description('Add an iDotMatrix device address')
+    .option('-n, --name <name>', 'Device name', 'iDotMatrix')
+    .option('-b, --brightness <value>', 'Brightness 5-100', '100')
+    .action(async (address, opts) => {
+    const { addIDotMatrixDevice } = await import('./idotmatrix/idotmatrix-settings.js');
+    const brightness = parseInt(opts.brightness, 10);
+    if (addIDotMatrixDevice({ address, name: opts.name, brightness: isNaN(brightness) ? 100 : brightness })) {
+        log(`Added ${opts.name} (${address}) with brightness ${brightness}% to settings.`);
+    }
+    else {
+        log(`Device ${address} already exists.`);
+    }
+});
+idotmatrix
+    .command('list')
+    .description('List configured iDotMatrix devices')
+    .action(async () => {
+    const { loadIDotMatrixDevices } = await import('./idotmatrix/idotmatrix-settings.js');
+    const devices = loadIDotMatrixDevices();
+    if (devices.length === 0) {
+        log('No iDotMatrix devices configured. Run `agentdeck idotmatrix scan` or `add`.');
+        return;
+    }
+    log(`${devices.length} device(s) configured:`);
+    for (const d of devices) {
+        const brightnessInfo = d.brightness !== undefined ? ` (brightness=${d.brightness}%)` : '';
+        log(`  ${d.name || 'iDotMatrix'} (${d.address})${brightnessInfo}`);
+    }
+});
+idotmatrix
+    .command('remove <address>')
+    .description('Remove an iDotMatrix device')
+    .action(async (address) => {
+    const { removeIDotMatrixDevice } = await import('./idotmatrix/idotmatrix-settings.js');
+    if (removeIDotMatrixDevice(address)) {
+        log(`Removed device ${address}.`);
+    }
+    else {
+        log(`Device ${address} not found.`);
+    }
+});
+idotmatrix
+    .command('brightness <value>')
+    .description('Set brightness of the iDotMatrix device (5-100)')
+    .option('-a, --address <address>', 'BLE Address (defaults to first configured device)')
+    .action(async (valueStr, opts) => {
+    const { loadIDotMatrixDevices } = await import('./idotmatrix/idotmatrix-settings.js');
+    const { dirname } = await import('path');
+    const { fileURLToPath } = await import('url');
+    const { spawn } = await import('child_process');
+    const value = parseInt(valueStr, 10);
+    if (isNaN(value) || value < 5 || value > 100) {
+        log('Brightness value must be between 5 and 100.');
+        process.exit(1);
+    }
+    let targetAddress = opts.address;
+    if (!targetAddress) {
+        const devices = loadIDotMatrixDevices();
+        if (devices.length === 0) {
+            log('No device specified and none configured. Use `agentdeck idotmatrix add <address>`.');
+            process.exit(1);
+        }
+        targetAddress = devices[0].address;
+    }
+    const distPath = dirname(fileURLToPath(import.meta.url));
+    const projectRoot = join(distPath, '..', '..');
+    const venvPython = join(projectRoot, '.venv', 'bin', 'python');
+    const brightnessScript = join(projectRoot, 'bridge', 'src', 'idotmatrix', 'brightness.py');
+    log(`Setting brightness of ${targetAddress} to ${value}%...`);
+    const py = spawn(venvPython, [brightnessScript, '-a', targetAddress, '-b', String(value)], {
+        stdio: 'inherit'
+    });
+    py.on('close', (code) => {
+        if (code === 0) {
+            log('Brightness updated successfully.');
+        }
+        else {
+            log(`Failed to update brightness, process exited with code ${code}`);
+        }
+    });
+});
+idotmatrix
+    .command('sync [address]')
+    .description('Sync AgentDeck dashboard frames to iDotMatrix BLE device')
+    .option('-p, --port <port>', 'Bridge server port')
+    .option('-b, --brightness <value>', 'Override brightness (5-100)')
+    .option('--boost <value>', 'Software brightness boost factor (default: 1.6)')
+    .action(async (addressOpt, opts) => {
+    const { loadIDotMatrixDevices } = await import('./idotmatrix/idotmatrix-settings.js');
+    const { readDaemonInfo, findDaemonPort } = await import('./session-registry.js');
+    const { dirname } = await import('path');
+    const { fileURLToPath } = await import('url');
+    const { spawn } = await import('child_process');
+    let targetAddress = addressOpt;
+    let defaultBrightness = 100;
+    const devices = loadIDotMatrixDevices();
+    if (!targetAddress) {
+        if (devices.length === 0) {
+            log('No device specified and none configured. Use `agentdeck idotmatrix add <address>`.');
+            process.exit(1);
+        }
+        targetAddress = devices[0].address;
+        defaultBrightness = devices[0].brightness ?? 100;
+        log(`Using first configured device: ${targetAddress}`);
+    }
+    else {
+        const matched = devices.find(d => d.address.toLowerCase() === targetAddress.toLowerCase());
+        if (matched) {
+            defaultBrightness = matched.brightness ?? 100;
+        }
+    }
+    const brightness = opts.brightness ? parseInt(opts.brightness, 10) : defaultBrightness;
+    const boost = opts.boost || '1.6';
+    const info = readDaemonInfo();
+    const port = opts.port != null
+        ? parseInt(opts.port, 10)
+        : (info?.httpPort ?? info?.port ?? findDaemonPort() ?? BRIDGE_WS_PORT);
+    const url = `http://127.0.0.1:${port}`;
+    const distPath = dirname(fileURLToPath(import.meta.url));
+    const projectRoot = join(distPath, '..', '..');
+    const venvPython = join(projectRoot, '.venv', 'bin', 'python');
+    const syncScript = join(projectRoot, 'bridge', 'src', 'idotmatrix', 'sync.py');
+    log(`Starting BLE sync client linking to bridge at ${url} (brightness ${brightness}%, boost ${boost}x)...`);
+    const py = spawn(venvPython, [syncScript, '-a', targetAddress, '-u', url, '-b', String(brightness), '--boost', String(boost)], {
+        stdio: 'inherit'
+    });
+    py.on('close', (code) => {
+        log(`Sync process exited with code ${code}`);
+    });
+});
+// ===== Divoom Timebox Mini Light commands =====
+const timebox = program.command('timebox').description('Manage Divoom Timebox Mini devices (Bluetooth LE)');
+timebox
+    .command('scan')
+    .description('Discover BLE TimeBox-mini-light peripherals')
+    .action(async () => {
+    const paths = resolveTimeboxSyncPaths();
+    log('Scanning for BLE devices (5 seconds)...');
+    const py = spawn(paths.python, [paths.scanScript]);
+    let stdoutData = '';
+    py.stdout.on('data', (data) => {
+        stdoutData += data.toString();
+    });
+    py.on('close', (code) => {
+        if (code !== 0) {
+            log('BLE scan failed (is bleak installed in .venv?).');
+            return;
+        }
+        try {
+            const devices = JSON.parse(stdoutData.trim());
+            if (devices.error) {
+                log(`BLE scan error: ${devices.error}`);
+                return;
+            }
+            if (!Array.isArray(devices) || devices.length === 0) {
+                log('No BLE devices found.');
+                return;
+            }
+            log('\nFound BLE devices:');
+            for (const d of devices) {
+                const prefix = d.is_timebox ? '★ [TimeBox-mini-light] ' : '  ';
+                const rssi = typeof d.rssi === 'number' ? ` ${d.rssi}dBm` : '';
+                log(`${prefix}${d.name} (${d.address})${rssi}`);
+            }
+            log('\nAdd the starred BLE device with: agentdeck timebox add <address>');
+        }
+        catch {
+            log(`Failed to parse BLE scan output: ${stdoutData}`);
+        }
+    });
+});
+timebox
+    .command('add <address>')
+    .description('Add a Timebox device by its BLE address')
+    .option('-n, --name <name>', 'Device name', 'Timebox Mini')
+    .option('-b, --brightness <value>', 'Brightness 0-100', '80')
+    .action(async (address, opts) => {
+    const { addTimeboxDevice } = await import('./timebox/timebox-settings.js');
+    const parsed = parseInt(opts.brightness, 10);
+    const brightness = Number.isFinite(parsed) ? Math.max(0, Math.min(100, parsed)) : 80;
+    if (addTimeboxDevice({ address, name: opts.name, brightness })) {
+        log(`Added ${opts.name} (BLE ${address}) with brightness ${brightness}% to settings.`);
+        log('Restart the daemon to start automatic Timebox sync.');
+    }
+    else {
+        log(`Device ${address} already exists (or has no valid address).`);
+    }
+});
+timebox
+    .command('list')
+    .description('List configured Timebox devices')
+    .action(async () => {
+    const { loadTimeboxDevices, deviceId } = await import('./timebox/timebox-settings.js');
+    const devices = loadTimeboxDevices();
+    if (devices.length === 0) {
+        log('No Timebox devices configured. Run `agentdeck timebox scan`, then `agentdeck timebox add <address>`.');
+        return;
+    }
+    log(`${devices.length} device(s):`);
+    for (const d of devices) {
+        const brightnessInfo = d.brightness !== undefined ? ` brightness=${d.brightness}%` : '';
+        log(`  [BLE] ${d.name || 'Timebox Mini'} (${deviceId(d)})${brightnessInfo}`);
+    }
+});
+timebox
+    .command('remove <address>')
+    .description('Remove a Timebox device by BLE address')
+    .action(async (target) => {
+    const { removeTimeboxDevice } = await import('./timebox/timebox-settings.js');
+    if (removeTimeboxDevice(target)) {
+        log(`Removed ${target}.`);
+    }
+    else {
+        log(`Device ${target} not found.`);
+    }
+});
+/**
+ * Spawn the BLE sync writer for a one-shot test or a continuous sync,
+ * resolving the target device from CLI args / configured devices.
+ */
+async function runTimeboxSync(targetOpt, opts, once) {
+    const { loadTimeboxDevices, deviceId } = await import('./timebox/timebox-settings.js');
+    const { readDaemonInfo, findDaemonPort } = await import('./session-registry.js');
+    const devices = loadTimeboxDevices();
+    let device = targetOpt
+        ? devices.find((d) => deviceId(d).toLowerCase() === targetOpt.toLowerCase())
+        : devices[0];
+    // Allow an ad-hoc BLE address that isn't in settings.
+    if (!device && targetOpt) {
+        device = { address: targetOpt };
+    }
+    if (!device) {
+        log('No device specified and none configured. Use `agentdeck timebox scan` and `agentdeck timebox add <address>`.');
+        process.exit(1);
+    }
+    const id = deviceId(device);
+    if (!targetOpt)
+        log(`Using first configured device: ${id} (BLE)`);
+    const defaultBrightness = device.brightness ?? 80;
+    const parsedBrightness = opts.brightness ? parseInt(opts.brightness, 10) : defaultBrightness;
+    const brightness = Number.isFinite(parsedBrightness) ? Math.max(0, Math.min(100, parsedBrightness)) : defaultBrightness;
+    const info = readDaemonInfo();
+    const bridgePort = opts.bridgePort != null
+        ? parseInt(opts.bridgePort, 10)
+        : (info?.httpPort ?? info?.port ?? findDaemonPort() ?? BRIDGE_WS_PORT);
+    const url = `http://127.0.0.1:${bridgePort}`;
+    const paths = resolveTimeboxSyncPaths();
+    const args = [paths.bleScript, '--address', id, '--url', url, '--brightness', String(brightness), ...(once ? ['--once'] : [])];
+    log(`${once ? 'Sending one Timebox frame' : 'Starting Timebox sync'} via BLE ${id} from ${url} (brightness ${brightness}%)...`);
+    const py = spawn(paths.python, args, { stdio: 'inherit' });
+    py.on('close', (code) => {
+        if (once) {
+            if (code === 0) {
+                log('Timebox test frame sent.');
+            }
+            else {
+                log(`Timebox test exited with code ${code}`);
+                process.exit(code ?? 1);
+            }
+        }
+        else {
+            log(`Timebox sync process exited with code ${code}`);
+        }
+    });
+}
+timebox
+    .command('test [target]')
+    .description('Send one AgentDeck frame to a Timebox Mini (BLE)')
+    .option('-p, --bridge-port <port>', 'Bridge server port')
+    .option('-b, --brightness <value>', 'Override brightness 0-100')
+    .action((targetOpt, opts) => runTimeboxSync(targetOpt, opts, true));
+timebox
+    .command('sync [target]')
+    .description('Sync AgentDeck dashboard frames to a Timebox Mini (BLE)')
+    .option('-p, --bridge-port <port>', 'Bridge server port')
+    .option('-b, --brightness <value>', 'Override brightness 0-100')
+    .action((targetOpt, opts) => runTimeboxSync(targetOpt, opts, false));
 // ===== Pixoo commands =====
 const pixoo = program.command('pixoo').description('Manage Pixoo64 LED matrix devices');
 pixoo
@@ -735,29 +1581,11 @@ program
     const { startDashboard } = await import('./tui/dashboard.js');
     await startDashboard(opts);
 });
-// ===== Backward compat: `agentdeck start` → `agentdeck daemon start` =====
-program
-    .command('start', { hidden: true })
-    .description('(legacy) Start daemon in foreground — use `agentdeck daemon start`')
-    .option('-p, --port <port>', 'Server port', String(BRIDGE_WS_PORT))
-    .option('-d, --debug', 'Enable debug logging')
-    .action(async (opts) => {
-    // Legacy: runs foreground (LaunchAgent plist compatibility)
-    const { findExistingDaemon } = await import('./session-registry.js');
-    const existing = findExistingDaemon();
-    if (existing) {
-        log(`Daemon already running on port ${existing.port} (PID ${existing.pid}).`);
-        process.exit(0);
-    }
-    const { startDaemon } = await import('./daemon-server.js');
-    await startDaemon({
-        port: parseInt(opts.port, 10),
-        debug: opts.debug,
-    });
-});
+// Note: there is no top-level `agentdeck start`. The daemon is started via
+// `agentdeck daemon start` (what the LaunchAgent/install paths already use —
+// see cli.ts ~368/413).
 // ===== Default command (no args) =====
-// If no command specified, show status or help
-program.action(async () => {
+async function showDefaultStatusOrHelp() {
     const { listActive } = await import('./session-registry.js');
     const sessions = listActive();
     if (sessions.length === 0) {
@@ -771,7 +1599,7 @@ program.action(async () => {
         log(`  [${type}] :${s.port} — ${s.projectName} (PID ${s.pid}, ${age}s)`);
     }
     log('\nRun `agentdeck --help` for all commands.');
-});
+}
 // ===== APME commands =====
 const apme = program.command('apme').description('Agent Performance Monitoring & Evaluation');
 apme
@@ -1042,25 +1870,6 @@ apme
     await apme.runner.drain();
     log(`Done. ${completed} run(s) evaluated.`);
 });
-apme
-    .command('tune')
-    .description('Manually trigger rubric auto-tuning')
-    .action(async () => {
-    const { initApme } = await import('./apme/index.js');
-    const apme = await initApme();
-    if (!apme) {
-        log('APME not available');
-        process.exit(1);
-    }
-    log('Running rubric tuner...');
-    const outcome = await apme.tuner.tune();
-    if (outcome.accepted) {
-        log(`Accepted rubric v${outcome.newVersion} (correlation ${outcome.baselineCorrelation?.toFixed(2) ?? '?'} → ${outcome.proposedCorrelation?.toFixed(2) ?? '?'})`);
-    }
-    else {
-        log(`Rejected: ${outcome.reason}`);
-    }
-});
 apme
     .command('vibe <runId> <verdict>')
     .description('Submit vibe feedback (approve|reject|neutral)')
@@ -1098,9 +1907,12 @@ apme
 });
 apme
     .command('export')
-    .description('Export runs + evals as JSONL')
-    .option('-n, --limit <n>', 'Number of runs', '100')
+    .description('Export runs (default) or tasks as JSONL/CSV — dataset for offline analysis or meta-eval')
+    .option('-n, --limit <n>', 'Maximum rows', '100')
     .option('-o, --output <file>', 'Output file (default: stdout)')
+    .option('-b, --by <unit>', 'Row unit: run | task', 'run')
+    .option('-f, --format <fmt>', 'Format: jsonl | csv', 'jsonl')
+    .option('--closed-only', 'Tasks only: skip in-progress tasks (no ended_at)', false)
     .action(async (opts) => {
     const { initApme } = await import('./apme/index.js');
     const { writeFileSync: wfs } = await import('fs');
@@ -1109,22 +1921,117 @@ apme
         log('APME not available');
         process.exit(1);
     }
-    const runs = apme.store.listRuns({ limit: parseInt(opts.limit, 10) || 100 });
-    const lines = [];
-    for (const r of runs) {
-        const evals = apme.store.listEvalsForRun(r.id);
-        const vibe = apme.store.latestVibeForRun(r.id);
-        lines.push(JSON.stringify({ ...r, evals, vibe }));
+    const limit = parseInt(opts.limit, 10) || 100;
+    const by = opts.by === 'task' ? 'task' : 'run';
+    const format = opts.format === 'csv' ? 'csv' : 'jsonl';
+    let rows;
+    if (by === 'task') {
+        // Task-unit dataset: one row per task (group of turns between
+        // boundary signals). This is the dataset format that supports
+        // meaningful agent evaluation per the user requirement —
+        // "의미 있는 단위의 세션을 데이터셋으로 저장".
+        const tasks = apme.store.listAllTasks({ limit, closedOnly: !!opts.closedOnly });
+        rows = tasks.map((t) => {
+            const turns = apme.store.listTurnsForTask(t.id);
+            const evals = apme.store.listEvalsForTask(t.id);
+            const run = apme.store.getRun(t.runId);
+            const vibe = apme.store.latestVibeForRun(t.runId);
+            const axes = {};
+            for (const e of evals) {
+                if (e.layer === 'task_judge')
+                    axes[e.metric] = e.score;
+            }
+            const overallEval = evals.find((e) => e.layer === 'task_judge' && e.metric === 'overall');
+            let reasoning = null;
+            let done = null;
+            let missed = null;
+            if (overallEval?.raw) {
+                try {
+                    const parsed = JSON.parse(overallEval.raw);
+                    reasoning = parsed.reasoning ?? null;
+                    done = parsed.done ?? null;
+                    missed = parsed.missed ?? null;
+                }
+                catch { /* ignore parse failure */ }
+            }
+            const toolCalls = turns.reduce((n, tu) => n + (tu.tool_calls ?? 0), 0);
+            const filesModified = turns.reduce((n, tu) => n + (tu.files_modified ?? 0), 0);
+            const filesCreated = turns.reduce((n, tu) => n + (tu.files_created ?? 0), 0);
+            const firstPrompt = turns[0]?.prompt ?? null;
+            const lastResponse = turns[turns.length - 1]?.response ?? null;
+            return {
+                taskId: t.id,
+                runId: t.runId,
+                taskIndex: t.taskIndex,
+                agentType: run?.agentType ?? null,
+                modelId: run?.modelId ?? null,
+                projectName: run?.projectName ?? null,
+                taskCategory: t.taskCategory ?? run?.taskCategory ?? null,
+                boundarySignal: t.boundarySignal,
+                startedAt: t.startedAt,
+                endedAt: t.endedAt,
+                durationSec: t.endedAt ? Math.round((t.endedAt - t.startedAt) / 1000) : null,
+                turnCount: turns.length,
+                firstTurnIndex: t.firstTurnIndex,
+                lastTurnIndex: t.lastTurnIndex,
+                toolCalls,
+                filesModified,
+                filesCreated,
+                firstPrompt: firstPrompt ? firstPrompt.slice(0, 500) : null,
+                lastResponse: lastResponse ? lastResponse.slice(0, 500) : null,
+                summary: t.summary ?? null,
+                composite: t.compositeScore ?? null,
+                outcome: t.outcome ?? null,
+                axes,
+                overall: axes.overall ?? null,
+                reasoning,
+                done,
+                missed,
+                vibeVerdict: vibe?.verdict ?? null,
+                vibeNote: vibe?.note ?? null,
+            };
+        });
     }
+    else {
+        const runRows = apme.store.listRuns({ limit });
+        rows = runRows.map((r) => {
+            const evals = apme.store.listEvalsForRun(r.id);
+            const vibe = apme.store.latestVibeForRun(r.id);
+            return { ...r, evals, vibe };
+        });
+    }
+    const output = format === 'csv' ? rowsToCsv(rows) : rowsToJsonl(rows);
     if (opts.output) {
-        wfs(opts.output, lines.join('\n') + '\n', 'utf-8');
-        log(`Exported ${runs.length} run(s) to ${opts.output}`);
+        wfs(opts.output, output, 'utf-8');
+        log(`Exported ${rows.length} ${by}(s) to ${opts.output} (${format})`);
     }
     else {
-        for (const line of lines)
-            process.stdout.write(line + '\n');
+        process.stdout.write(output);
     }
 });
+function rowsToJsonl(rows) {
+    return rows.map((r) => JSON.stringify(r)).join('\n') + (rows.length ? '\n' : '');
+}
+function rowsToCsv(rows) {
+    if (rows.length === 0)
+        return '';
+    const headerSet = new Set();
+    for (const r of rows)
+        for (const k of Object.keys(r))
+            headerSet.add(k);
+    const headers = Array.from(headerSet);
+    const escape = (v) => {
+        if (v === null || v === undefined)
+            return '';
+        const s = typeof v === 'object' ? JSON.stringify(v) : String(v);
+        return /[,"\n]/.test(s) ? '"' + s.replace(/"/g, '""') + '"' : s;
+    };
+    const lines = [
+        headers.join(','),
+        ...rows.map((r) => headers.map((h) => escape(r[h])).join(',')),
+    ];
+    return lines.join('\n') + '\n';
+}
 apme
     .command('rubric')
     .description('Show current judge rubric')
@@ -1234,5 +2141,26 @@ apme
         log(`  ${c.taskCategory.padEnd(16)} ${c.modelId.slice(0, 22).padEnd(22)} ${String(c.runs).padEnd(6)} ${score.padEnd(8)} ${tests.padEnd(8)} ${cost}`);
     }
 });
-program.parse();
+function isMainModule() {
+    if (!process.argv[1])
+        return false;
+    const thisFile = fileURLToPath(import.meta.url);
+    try {
+        return realpathSync(thisFile) === realpathSync(process.argv[1]);
+    }
+    catch {
+        return thisFile === process.argv[1];
+    }
+}
+export async function runCli(argv = process.argv) {
+    if (argv.slice(2).length === 0) {
+        await showDefaultStatusOrHelp();
+        return;
+    }
+    program.parse(argv);
+}
+export { program };
+if (isMainModule()) {
+    void runCli();
+}
 //# sourceMappingURL=cli.js.map