@agentdeck/bridge 1.2.0 → 1.2.1

package/dist/daemon-server.js

@@ -24,6 +24,8 @@ import { PassiveSessionObserver } from './passive-observer.js';
 import { SessionTimelineRelay } from './session-timeline-relay.js';
 import { SessionFocusRelay } from './session-focus-relay.js';
 import { SubagentTimelineTracker } from './subagent-timeline.js';
+import { CoordinationTracker } from './coordination-evidence.js';
+import { HookOpenCodeSessions } from './hook-opencode-sessions.js';
 import { getRemoteSession, getRemoteSender, listRemoteEnriched, } from './remote-sessions.js';
 import { createPushChannelHandler } from './session-push-channel.js';
 import { setAwaitingOverlay, setPermissionNotificationOverlay, setAskUserQuestionOverlay, advanceAskUserQuestionOverlay, getAskUserQuestionAnswers, clearAwaitingOverlay, clearAskUserQuestionOverlay, getAwaitingOverlay, isPermissionNotification, applyAwaitingOverlayToObserved, } from './awaiting-overlay.js';
@@ -71,13 +73,28 @@ const ASK_GATE_HOLD_MS = Math.min(50_000, Math.max(5_000, Number(process.env.AGE
  *  invisible to this daemon, so only elapsed silence protects them (runs this
  *  daemon still holds are skipped via `collector.isLiveRun`). */
 const APME_ABANDONED_RUN_STALE_SEC = Math.max(600, Number(process.env.AGENTDECK_APME_ABANDON_SEC) || 7200);
+/** Backlog tasks handed to the judge per eval tick when it is idle — see the drain. */
+const APME_TASK_JUDGE_DRAIN_PER_TICK = 1;
+/** How many backlog candidates the drain looks at to find one it may feed.
+ *  Much larger than the per-tick budget on purpose — see the drain for why.
+ *  Reading rows is free (one indexed SELECT); only the judge call is serial.
+ *  Sized so a run of consecutive poison tasks at the head cannot fill the whole
+ *  window and starve the older backlog behind them the way one task did. */
+const APME_TASK_JUDGE_DRAIN_WINDOW = 200;
+/** How often a judge backend that last probed unavailable is probed again.
+ *  The probe used to run once, at startup; a local MLX server busy with
+ *  someone else's inference at that moment answered nothing inside the
+ *  probe's 8 s, and the backlog drain — gated on that one answer — stayed
+ *  off for the life of the process (2026-09-03, 289 tasks pending). */
+const APME_JUDGE_REPROBE_MS = 5 * 60_000;
 import { VoiceManager } from './voice.js';
 import { VoiceAssistantManager } from './voice-assistant.js';
 import { listActive as listActiveSessions, findAvailablePort, findExistingDaemon, probeDaemonHealth, requestDaemonShutdown, scanDaemonPortWindow, shouldConcedePortToOccupant, waitForDaemonExit, waitForPortBindable, writeDaemonInfo, ensureDaemonInfo, removeDaemonInfo, readDaemonInfo, removeDaemonSession, getCandidateDataDirs, getDataDir, getOwnTimelineFile, } from './session-registry.js';
 import { isForeignDaemon } from './daemon-takeover.js';
 import { loadDaemonSettings } from './daemon-settings.js';
 import { resolveDaemonPort, describeDaemonPortSource, PREFERRED_PORT_RECLAIM_MS, } from './daemon-port.js';
-import { fetchUsageFromApi, resetConsecutiveFailures } from './usage-api.js';
+import { enableClaudeUsageRecovery, fetchUsageFromApi, resetConsecutiveFailures } from './usage-api.js';
+import { stopClaudeUsageRecoveryChildren } from './claude-usage-recovery.js';
 import { getOrCreateToken, isLocalConnection, validateToken } from './auth.js';
 import { buildPublicHealth, gateHttpRequest, isAuthorizedHttpRequest } from './http-auth-gate.js';
 import { closePairingWindow, getPairingWindowStatus, openPairingWindow, pairingWindowOpen, redeemPairingCode, } from './pairing-window.js';
@@ -90,9 +107,12 @@ import { rgbToBmp, pixooLiveHtml } from './hook-server.js';
 import { enableDebugLog, debug, debugThrottled } from './logger.js';
 import { LegacyRearmLedger } from './legacy-rearm-ledger.js';
 import { CodexOtelTracker, CODEX_OTEL_TRACES_PATH, spanNameSummary } from './codex-otel.js';
-import { HookCodexSessions } from './hook-codex-sessions.js';
+import { HookCodexSessions, buildCodexPermissionQuestion } from './hook-codex-sessions.js';
 import { ObservedTurnWatchdogs } from './observed-turn-watchdogs.js';
-import { initApme, isTimelineProjectionEnabled, loadApmeConfig } from './apme/index.js';
+import { getApmeInitFailure, initApme, isTimelineProjectionEnabled, loadApmeConfig, } from './apme/index.js';
+import { taskGradeability, retractUngradeableVerdicts } from './apme/task-gradeability.js';
+import { resolveStopResponse } from './hook-response-source.js';
+import { scheduleDeferredReplyRead } from './deferred-reply-read.js';
 import { FallbackTaskTimeline } from './fallback-task-timeline.js';
 import { handleApmeRequest } from './apme/http.js';
 import { readModelFromTranscript } from './apme/claude-transcript-reader.js';
@@ -102,7 +122,7 @@ import { KiroTimelineFeed } from './kiro-timeline-feed.js';
 import { OpenClawTimelineFeed, OPENCLAW_FEED_INTERVAL_MS } from './openclaw-timeline-feed.js';
 import { DeviceVoiceReplyRouter, speakableReply, spokenDigest, pcmFromWav, } from './device-voice-reply.js';
 import { rawSessionId } from '@agentdeck/shared';
-import { codexTurnOutcomeFromRollout, lastAgentMessageFromCodexRollout } from './codex-rollout-response.js';
+import { codexTurnOutcomeFromRollout, codexTurnOutcomeFromRolloutPath, lastAgentMessageFromCodexRollout } from './codex-rollout-response.js';
 import { callFoundationModelsHelper } from './foundation-models-helper.js';
 import { initModules, stopModules, createDefaultModules, } from './modules/index.js';
 import { bindHostFor, daemonModuleConfigs, describeDaemonPosture, resolveDaemonPosture, } from './network-posture.js';
@@ -114,6 +134,7 @@ import { getPixooDeviceDetails, pixooDeviceCount } from './pixoo/pixoo-bridge.js
 import { loadTimeboxDevices } from './timebox/timebox-settings.js';
 import { getLanIp, stripUnsafeText, cleanRawText, prepareMarkdownDetail, normalizeCommandPrompt, formatDurationSec } from '@agentdeck/shared';
 import { injectOpenClawSession, OPENCLAW_SESSION_ID } from './openclaw-session.js';
+import { GatewayFlapTracker, GATEWAY_FLAP_WINDOW_MS, diagnoseGatewayLog, formatGatewayInstability, readGatewayLogTail, } from './openclaw-gateway-stability.js';
 import { buildCardFeed, buildGlance, projectPortableReaderGlance, applyOutboxDecisions, FeedPullTracker, formatFeedPull, applyPullOtaBootstrap, OutboxIdempotencyLedger, normalizeClientIp, parsePullTelemetry, } from './card-feed.js';
 import { threadModule } from './card-modules.js';
 import { AutonomousPocketEngine, createAutonomousPocketModules, parsePocketAutonomyConfig, } from './pocket-autonomy.js';
@@ -957,12 +978,15 @@ export function classifyObservedHookEvent(eventName, mapped) {
     if (eventName === 'codex_subagent_start' || eventName === 'codex_subagent_stop') {
         return { boundary: eventName, agentType: 'codex-cli' };
     }
-    const prefixed = /^(codex|opencode|antigravity|kiro|kiro_ide)_(agent_spawn|session_start|session_end|user_prompt_submit|tool_start|tool_end|stop|turn_complete|notification|permission_asked|permission_replied)$/
+    const prefixed = /^(codex|opencode|antigravity|kiro|kiro_ide)_(agent_spawn|session_start|session_end|user_prompt_submit|tool_start|tool_end|stop|turn_complete|interrupt|notification|permission_request|permission_asked|permission_replied)$/
         .exec(eventName);
     if (!prefixed)
         return { boundary: mapped, agentType: 'claude-code' };
     return {
-        boundary: prefixed[2] === 'turn_complete' ? 'stop'
+        // `interrupt` (Codex Ctrl+C) is a turn END with no Stop coming, so it
+        // rides the stop boundary; the caller stamps `interrupted` on the payload
+        // so the collector records `end_source='interrupted'`.
+        boundary: prefixed[2] === 'turn_complete' || prefixed[2] === 'interrupt' ? 'stop'
             : prefixed[2] === 'agent_spawn' ? 'session_start'
                 : prefixed[2],
         agentType: prefixed[1] === 'codex' ? 'codex-cli'
@@ -1303,6 +1327,7 @@ export async function startDaemon(opts) {
     // Codex sessions known only from `codex_*` hooks — the backstop for when the
     // process scan can't see one (lsof timeout, no rollout held open).
     const hookCodexSessions = new HookCodexSessions();
+    const hookOpenCodeSessions = new HookOpenCodeSessions();
     // Declared before the HTTP server: the PreToolUse route reads it to decide
     // whether this daemon can type into a session's terminal, and hooks start
     // arriving the moment the port binds — several hundred milliseconds before
@@ -1353,6 +1378,55 @@ export async function startDaemon(opts) {
     // `gatewaySessionState` / `gatewayModelName` dedicated fields.
     let gatewaySessionState = 'idle';
     let gatewayModelName;
+    // Restart-storm detector for the Gateway link. Each disconnect is a flap;
+    // three inside ten minutes is an instability, and the reason is read off
+    // OpenClaw's own log tail because nothing on this side can know it. The
+    // finding rides `/status` + `/health` (`gateway.instability`) and one
+    // `error` timeline row per escalation, so a link that keeps "recovering"
+    // cannot pass for healthy on any surface. Cleared once the window drains.
+    const gatewayFlaps = new GatewayFlapTracker();
+    let gatewayInstability = null;
+    let gatewayInstabilityAssessing = false;
+    async function assessGatewayInstability(nowMs) {
+        if (gatewayInstabilityAssessing)
+            return;
+        const a = gatewayFlaps.assess(nowMs);
+        if (!a.unstable)
+            return;
+        // Escalate only when the count grows; a stable count is old news.
+        if (gatewayInstability && gatewayInstability.flapsInWindow >= a.flapsInWindow)
+            return;
+        gatewayInstabilityAssessing = true;
+        try {
+            const diagnosis = diagnoseGatewayLog(await readGatewayLogTail());
+            gatewayInstability = {
+                flapsInWindow: a.flapsInWindow,
+                windowMs: GATEWAY_FLAP_WINDOW_MS,
+                since: a.since ?? nowMs,
+                lastFlapAt: nowMs,
+                diagnosis,
+            };
+            const line = formatGatewayInstability(gatewayInstability);
+            log(`[agentdeck] ${line}${diagnosis ? ` — ${diagnosis.hint}` : ''}`);
+            core.bridgeTimeline.addEntry({
+                ts: nowMs, type: 'error',
+                raw: line.slice(0, 197),
+                detail: diagnosis ? `${diagnosis.hint}\n\n${diagnosis.line}` : undefined,
+                sessionId: OPENCLAW_SESSION_ID,
+                agentType: 'openclaw',
+            });
+            core.stateMachine.emit('state_changed', core.stateMachine.getSnapshot());
+        }
+        finally {
+            gatewayInstabilityAssessing = false;
+        }
+    }
+    function settleGatewayInstability(nowMs) {
+        if (gatewayInstability && !gatewayFlaps.assess(nowMs).unstable) {
+            log('[agentdeck] OpenClaw Gateway stable again — instability cleared');
+            gatewayInstability = null;
+        }
+    }
     /**
      * Snapshot for an `openclaw` state event: the global machine with the
      * Gateway-local model pinned back on.
@@ -1436,6 +1510,9 @@ export async function startDaemon(opts) {
     // Assigned after BridgeCore exists. The HTTP handler reads it only after
     // startup; nullable keeps the tiny listen→core initialization window safe.
     let subagentTimeline = null;
+    // Cross-session coordination (spawned workers, peer messages, background
+    // jobs) — the second census axis beside `subagents`. See coordination-evidence.ts.
+    const coordination = new CoordinationTracker();
     // The learning pack is immutable for one daemon lifetime. Package upgrades
     // arrive with a new AgentDeck build; validating once keeps every sleeping
     // reader pull cheap while a corrupt/mislicensed bundle fails closed.
@@ -1558,6 +1635,9 @@ export async function startDaemon(opts) {
             res.end(JSON.stringify({
                 status: 'ok', mode: 'daemon', state: snap.state,
                 gateway: gatewayAdapter?.isAlive() ? 'connected' : 'disconnected',
+                // A link that keeps reconnecting reads `connected` at every sample.
+                // This is the field that says the samples were lying (null = stable).
+                gatewayInstability,
                 uptime: process.uptime(), port, pid: process.pid,
                 // Which build is SERVING this port. Captured when this process started
                 // (see daemon-build-identity.ts) and never recomputed, so a rebuild
@@ -1583,7 +1663,10 @@ export async function startDaemon(opts) {
                         dbPath: apme.store.dbPath,
                         judgeBackend: apme.runner.lastBackendProbe ?? { status: 'unknown', backend: loadApmeConfig().judge.backend },
                     }
-                    : { enabled: false, error: apme === null ? 'see startup logs (initApme returned null)' : 'unknown' },
+                    : {
+                        enabled: false,
+                        error: getApmeInitFailure() ?? 'unknown init failure',
+                    },
             }));
             return;
         }
@@ -1743,6 +1826,7 @@ export async function startDaemon(opts) {
                     available: core.cachedGatewayAvailable,
                     connected: core.cachedGatewayConnected,
                     hasError: core.cachedGatewayHasError,
+                    instability: gatewayInstability,
                 },
                 clients: core.wsServer.getClientCount(),
                 modules: moduleHealthProvider(),
@@ -2627,6 +2711,15 @@ export async function startDaemon(opts) {
                     json = body ? JSON.parse(body) : {};
                 }
                 catch { /* ignore */ }
+                // The hook shell's parent pid (`X-AgentDeck-Pid: $PPID` in the
+                // installed snippet) — the only consent-free session→process link.
+                // Carried inside the payload as `agentdeck_pid` so every consumer
+                // downstream sees one shape; a payload that already names one wins.
+                const pidHeader = req.headers['x-agentdeck-pid'];
+                const headerPid = Number(Array.isArray(pidHeader) ? pidHeader[0] : pidHeader);
+                if (Number.isInteger(headerPid) && headerPid > 1 && json.agentdeck_pid == null) {
+                    json.agentdeck_pid = headerPid;
+                }
                 // Map PascalCase event names to snake_case for state machine + APME
                 const eventMap = {
                     SessionStart: 'session_start', SessionEnd: 'session_end',
@@ -2643,6 +2736,10 @@ export async function startDaemon(opts) {
                 // codex/opencode *state* is owned by the passive observer's turn
                 // semantics, not these hooks.
                 const { boundary, agentType: hookAgentType } = classifyObservedHookEvent(eventName, mapped);
+                // A Codex/OpenCode Interrupt is the user's Ctrl+C: the turn ended with
+                // no Stop, and the collector must not read it as a normal stop.
+                if (/_interrupt$/.test(eventName))
+                    json.interrupted = true;
                 const earlyHookSid = typeof json.session_id === 'string' && json.session_id
                     ? json.session_id : 'daemon-hook';
                 const earlyHookCwd = (typeof json.cwd === 'string' ? json.cwd
@@ -2665,6 +2762,12 @@ export async function startDaemon(opts) {
                 if (childResult?.censusChangedFor) {
                     core.broadcastSessionsList().catch(() => { });
                 }
+                if (childResult?.sampleEvent) {
+                    apme?.collector.noteSubagentLifecycle(earlyHookSid, childResult.sampleEvent);
+                }
+                if (childResult?.infoEvent) {
+                    apme?.collector.noteInfo(earlyHookSid, childResult.infoEvent);
+                }
                 const childHook = childResult?.childOnly === true;
                 if (childHook) {
                     // Child activity is observation-only. Never let child PreToolUse
@@ -2686,6 +2789,39 @@ export async function startDaemon(opts) {
                         projectName: earlyHookProject,
                         toolName: typeof json.tool_name === 'string' ? json.tool_name : undefined,
                     });
+                    // Codex PERM: `PermissionRequest` fires only when Codex is about to
+                    // ask the user (approval_policy on-request), so it is a genuine
+                    // awaiting signal with no prediction — display-only, respond in the
+                    // terminal. Any later lifecycle hook on the session ends the wait:
+                    // an approval runs the tool (tool_start/tool_end), a denial or
+                    // Ctrl+C ends the turn (stop/interrupt), a new prompt supersedes it.
+                    const codexSid = typeof json.session_id === 'string' ? json.session_id : '';
+                    if (codexSid) {
+                        if (eventName === 'codex_permission_request') {
+                            // `sticky`: the transcript-recency drop is a Claude ESC heuristic;
+                            // a Codex rollout may be appended while the approval waits, and
+                            // the explicit hook clears below already end this wait.
+                            setAwaitingOverlay(codexSid, buildCodexPermissionQuestion(json), undefined, { sticky: true });
+                            core.broadcastSessionsList().catch(() => { });
+                        }
+                        else if (getAwaitingOverlay(codexSid)?.kind === 'permission') {
+                            if (clearAwaitingOverlay(codexSid))
+                                core.broadcastSessionsList().catch(() => { });
+                        }
+                    }
+                }
+                // OpenCode observed rows: the process scan keys them by PID and knows
+                // nothing about turns or permissions; the observer plugin's hooks key
+                // by OpenCode session id and carry both. See hook-opencode-sessions.ts.
+                if (eventName.startsWith('opencode_')) {
+                    hookOpenCodeSessions.note(eventName, {
+                        sessionId: typeof json.session_id === 'string' ? json.session_id : undefined,
+                        cwd: earlyHookCwd || undefined,
+                        projectName: earlyHookProject,
+                        toolName: typeof json.tool_name === 'string' ? json.tool_name : undefined,
+                        permissionId: typeof json.permission_id === 'string' ? json.permission_id : undefined,
+                        title: typeof json.title === 'string' ? json.title : undefined,
+                    });
                 }
                 // State machine
                 if (mapped === 'session_start')
@@ -2751,7 +2887,7 @@ export async function startDaemon(opts) {
                         // never held again this session. User prompt / session end clear
                         // pending STOP + queued directives (the user took over).
                         if (mapped === 'tool_end') {
-                            noteToolEnd(claudeSid, toolName || undefined);
+                            noteToolEnd(claudeSid, toolName || undefined, toolUseId);
                         }
                         else if (mapped === 'user_prompt_submit') {
                             if (clearOnUserPrompt(claudeSid))
@@ -2850,6 +2986,10 @@ export async function startDaemon(opts) {
                 // Mirrors the Swift daemon's session_end force-close (`hasOpenTurn`
                 // → interrupted chat_end).
                 if (boundary === 'session_end') {
+                    // Every child the session had ends with it — a lost SubagentStop
+                    // must not pin "+N" on a row that no longer exists.
+                    subagentTimeline?.forget(hookSid);
+                    coordination.forget(hookSid);
                     const rows = core.bridgeTimeline.getHistoryForSession(hookSid, undefined, 24);
                     let lastStart;
                     let lastCompletionTs = 0;
@@ -2909,13 +3049,35 @@ export async function startDaemon(opts) {
                         // codex_* / opencode_* names would silently skip turn management.
                         apme.collector.ingestHook(hookSid, boundary, json);
                     }
+                    // Coordination evidence carried BY the hook itself: a received
+                    // cross-session envelope, a SendMessage call, a `claude -p` launch.
+                    // After ingestHook so a prompt's turn is open before the relation
+                    // is attached to it. Process-table evidence (ancestry, background
+                    // jobs) arrives on the observer tick instead.
+                    if (typeof json.agentdeck_pid === 'number') {
+                        coordination.registerPid(hookSid, json.agentdeck_pid, passiveSessionObserver.processes());
+                    }
+                    if (boundary === 'user_prompt_submit' && hookPromptText) {
+                        persistRelation(coordination.noteMessageIn(hookSid, hookPromptText));
+                    }
+                    else if (eventName === 'PostToolUse' || boundary === 'tool_end') {
+                        persistRelation(coordination.noteToolCall(hookSid, json.tool_name, json.tool_input));
+                    }
                     // Direct `claude` runs reach the daemon only via these hooks, which
                     // never carry the model — so every such run persisted model_id=NULL.
                     // Recover it from the transcript Claude writes. Must run before
                     // closeRun tears down the session→run mapping.
                     if (boundary === 'stop' || boundary === 'session_end') {
+                        // Codex states its model on the hook itself (`model`); Claude's
+                        // transcript holds it. `transcript_path` on a Codex hook is its
+                        // ROLLOUT, which the Claude reader cannot parse — so every Codex
+                        // run persisted model_id=NULL while the payload said `gpt-5.6`.
+                        const inlineModel = typeof json.model === 'string' ? json.model.trim() : '';
                         const tp = json.transcript_path;
-                        if (typeof tp === 'string' && tp) {
+                        if (inlineModel) {
+                            apme.collector.updateModel(hookSid, inlineModel);
+                        }
+                        else if (hookAgentType === 'claude-code' && typeof tp === 'string' && tp) {
                             const model = readModelFromTranscript(tp);
                             if (model)
                                 apme.collector.updateModel(hookSid, model);
@@ -2994,18 +3156,31 @@ export async function startDaemon(opts) {
                         json.result,
                     ]
                         .find((v) => typeof v === 'string' && v.trim().length > 0) ?? '';
-                    // Codex's stop payload rarely carries the text inline; its rollout
-                    // JSONL (agent_message / task_complete records) is the
-                    // authoritative source — the Codex counterpart of Claude's
-                    // transcript tail. Read it whenever a completion row might be
-                    // emitted (open turn, or a response-only close below).
-                    const rolloutOutcome = hookAgentType === 'codex-cli' && !tp && !inlineResponse
-                        ? codexTurnOutcomeFromRollout(hookSid)
-                        : { text: '', error: undefined, errorKind: undefined };
-                    const rolloutResponse = rolloutOutcome.text;
-                    const responseText = tp
-                        ? stripUnsafeText(lastAssistantTextFromTranscript(tp))
-                        : stripUnsafeText(inlineResponse || rolloutResponse);
+                    // Where the reply comes from is decided per AGENT, and inline text
+                    // wins wherever it exists — it is the hook's own statement of what
+                    // the agent said. Otherwise Claude's transcript is read by the
+                    // Claude reader and Codex's rollout by the Codex reader. The old
+                    // rule was "transcript_path ⇒ Claude reader", and a Codex hook
+                    // carries a transcript_path too — its rollout — so every Codex turn
+                    // read '' while `last_assistant_message` sat in the same payload
+                    // (3 of 128 codex stop-turns held a response in one week, measured
+                    // 2026-09-03; the judge scored the rest against silence).
+                    const resolved = resolveStopResponse({ agentType: hookAgentType, sessionId: hookSid, inlineResponse, transcriptPath: tp }, {
+                        readClaudeTranscript: lastAssistantTextFromTranscript,
+                        readCodexRolloutPath: codexTurnOutcomeFromRolloutPath,
+                        readCodexRolloutById: codexTurnOutcomeFromRollout,
+                    });
+                    const rolloutOutcome = resolved.rollout;
+                    const responseText = stripUnsafeText(resolved.text);
+                    // An empty transcript read AT the Stop is not an answer — Claude is
+                    // still writing the record the hook refers to. Re-read shortly and
+                    // hand it to the last-closed turn (see deferred-reply-read.ts).
+                    if (!responseText && apme && hookAgentType === 'claude-code' && tp) {
+                        scheduleDeferredReplyRead(() => stripUnsafeText(lastAssistantTextFromTranscript(tp)), (text) => {
+                            apme?.collector.setLastClosedTurnResponse(hookSid, text);
+                            debug('APME', `deferred transcript read recovered ${text.length} chars for ${hookSid.slice(0, 8)}`);
+                        });
+                    }
                     const respRaw = responseText.length > 0
                         ? cleanRawText(responseText.length > 200 ? responseText.slice(0, 197) + '...' : responseText)
                         : '';
@@ -3223,6 +3398,7 @@ export async function startDaemon(opts) {
                                     // the signature is suppressed for this session.
                                     gateReleased(claudeSid, requestId, {
                                         undecided: decision === 'pass', tool: toolName, toolInput,
+                                        toolUseId: typeof json.tool_use_id === 'string' ? json.tool_use_id : undefined,
                                     });
                                     clearAwaitingOverlay(claudeSid);
                                     core.broadcastSessionsList().catch(() => { });
@@ -3583,6 +3759,7 @@ export async function startDaemon(opts) {
     // Keep the original startedAt stable when the self-heal timer rewrites it.
     const daemonInfo = { port, pid: process.pid, startedAt: new Date().toISOString() };
     writeDaemonInfo(daemonInfo);
+    enableClaudeUsageRecovery();
     // ===== BridgeCore =====
     const core = new BridgeCore({
         port,
@@ -3640,7 +3817,8 @@ export async function startDaemon(opts) {
         // event and WiFi resumes automatically — no state migration needed.
         if (SERIAL_FORWARDED_EVENTS.has(event.type) && isWifiEsp32RedundantWithSerial(client))
             return null;
-        return prepareForSerial(event);
+        const identity = wifiEsp32IdentityForSocket(client);
+        return prepareForSerial(event, identity?.board ? { deviceInfo: { board: identity.board } } : undefined);
     });
     // Timeline
     //
@@ -4139,6 +4317,41 @@ export async function startDaemon(opts) {
             log('[agentdeck] APME timeline projection ENABLED — chat/tool rows derive from SessionSample');
         }
         log(`[agentdeck] APME enabled — store=${apme.store.dbPath} routes=/apme/*`);
+        // Re-adopt the runs the previous daemon left open BEFORE any hook is
+        // served: a session that carried on across the restart continues its run
+        // instead of stranding it for the reaper (see `rehydrateOpenRuns`).
+        // Rows the OLD reaper stamped `orphaned` on evidence that now reads
+        // `idle_gap` — one idempotent pass, evidence-gated (see the store).
+        try {
+            const reclassified = apme.store.reclassifyReapedTasks();
+            if (reclassified > 0)
+                log(`[agentdeck] APME re-stamped ${reclassified} reaped task(s) as idle_gap — every turn had closed normally`);
+        }
+        catch { /* store logs it */ }
+        // Verdicts the judge reached on tasks it would now decline — scored
+        // against silence, or on a usage-limit notice — are withdrawn so they
+        // stop ranking real work. Bounded to the same 30-day window the backlog
+        // drain reads; idempotent after the first pass.
+        try {
+            const r = retractUngradeableVerdicts(apme.store, Date.now() - 30 * 86_400_000);
+            const n = r.no_reply + r.aborted_only + r.trivial;
+            if (n > 0)
+                log(`[agentdeck] APME withdrew ${n} verdict(s) reached without the agent's work — no reply ${r.no_reply}, client-ended ${r.aborted_only}, trivial ${r.trivial}`);
+            if (r.readmitted > 0)
+                log(`[agentdeck] APME re-admitted ${r.readmitted} declined task(s) to the judge backlog — their tool trajectory is the agent's work`);
+        }
+        catch (err) {
+            log(`[agentdeck] APME verdict retraction failed: ${String(err)}`);
+        }
+        try {
+            const r = apme.collector.rehydrateOpenRuns();
+            if (r.runs > 0) {
+                log(`[agentdeck] APME resumed ${r.runs} open run(s) from the store — ${r.tasks} task(s), ${r.turns} open turn(s), ${r.armed} idle-gap timer(s) re-armed${r.recovered > 0 ? `, ${r.recovered} turn(s) closed from the agent's own record` : ''}`);
+            }
+        }
+        catch (err) {
+            log(`[agentdeck] APME rehydrate failed: ${String(err)}`);
+        }
         // Fire-and-forget judge backend probe. Result is cached on
         // apme.runner.lastBackendProbe and surfaced on /health so users discover
         // misconfiguration (no MLX server running, missing API key, etc.) without
@@ -4167,6 +4380,33 @@ export async function startDaemon(opts) {
     // The observer scans in the background now (collect() returns the cache
     // immediately). When a scan lands fresh observations, push them out via
     // the debounced broadcast so clients don't wait for the next 10 s poll.
+    // A relation lands on the session's active APME task; a change to any
+    // census rebroadcasts the roster, because a background job starting or a
+    // spawned worker exiting moves nothing else a client could notice.
+    const persistRelation = (rel) => {
+        if (!rel)
+            return false;
+        apme?.collector.noteRelation(rel.sessionId, rel);
+        return true;
+    };
+    // Driven by its own timer, not by `onRefreshed`: that edge fires only when
+    // the observed PROCESS SET changes, and a background job appearing or a
+    // worker finishing changes the process table without changing that set —
+    // the same trap the OpenClaw transcript feed fell into.
+    const coordinationTick = () => {
+        const peers = coordination.mergePeers(passiveSessionObserver.collect([])
+            .filter((s) => typeof s.pid === 'number' && s.pid > 0)
+            .map((s) => ({ sessionId: rawSessionId(s.id), pid: s.pid })));
+        let changed = false;
+        for (const rel of coordination.observe(passiveSessionObserver.processes(), peers)) {
+            if (persistRelation(rel))
+                changed = true;
+        }
+        if (changed)
+            core.broadcastSessionsList().catch(() => { });
+    };
+    const coordinationTimer = setInterval(coordinationTick, 5_000);
+    coordinationTimer.unref?.();
     passiveSessionObserver.onRefreshed = () => {
         // Kiro pushes nothing: no `kiro_*` hook has ever reached this daemon, so
         // without a producer here its session shows in the HUD while the timeline
@@ -4227,6 +4467,7 @@ export async function startDaemon(opts) {
     // worth a broadcast of its own.
     codexOtel.onChanged = () => core.maybeBroadcastSessionsList();
     hookCodexSessions.onChanged = () => core.maybeBroadcastSessionsList();
+    hookOpenCodeSessions.onChanged = () => core.maybeBroadcastSessionsList();
     // ===== Gateway adapter lifecycle =====
     // (gatewayAdapter + gatewayConnecting declared earlier, before HTTP server)
     // Inject OpenClaw virtual session only after Gateway authentication succeeds.
@@ -4242,7 +4483,7 @@ export async function startDaemon(opts) {
         // synthesize a `codex-app` row for any thread the process scan missed —
         // Swift's only Codex-app source, here a second opinion on top of the
         // observer. See bridge/src/codex-otel.ts.
-        const observed = applyAwaitingOverlayToObserved(hookCodexSessions.applyTo(codexOtel.applyTo(passiveSessionObserver.collect(sessions))))
+        const observed = applyAwaitingOverlayToObserved(hookOpenCodeSessions.applyTo(hookCodexSessions.applyTo(codexOtel.applyTo(passiveSessionObserver.collect(sessions)))))
             .map((s) => {
             // Steering feedback for observed Claude sessions: devices render
             // "stopping at next tool" / queued-directive badges from these.
@@ -4276,6 +4517,7 @@ export async function startDaemon(opts) {
         // while these rows are `observed:<agent>:<uuid>`, so normalize before the
         // lookup — the two id forms are the standing trap here.
         const subagentCensus = subagentTimeline?.summaries() ?? new Map();
+        const coordinationCensus = coordination.summaries();
         const enrichedSessions = [...sessions, ...observed, ...remote].map((s) => {
             // On-demand review badge (REVIEW tile verdict / REVIEWING state) —
             // applies to every session type, managed included.
@@ -4285,7 +4527,10 @@ export async function startDaemon(opts) {
             // field that disappears when the last child exits latches "8 running" on
             // every client that merges retain-on-absent.
             const census = subagentCensus.get(rawSessionId(withReview.id));
-            const withCensus = census ? { ...withReview, subagents: census } : withReview;
+            const withSubagents = census ? { ...withReview, subagents: census } : withReview;
+            // Same emission rule for the coordination census: zeros once observed.
+            const coord = coordinationCensus.get(rawSessionId(withReview.id));
+            const withCensus = coord ? { ...withSubagents, coordination: coord } : withSubagents;
             if (withCensus.elapsedSec != null || !withCensus.startedAt)
                 return withCensus;
             const sec = Math.round((now - Date.parse(withCensus.startedAt)) / 1000);
@@ -4516,6 +4761,7 @@ export async function startDaemon(opts) {
                         gatewaySessionState = 'idle';
                         bridgeLogStream.start();
                         log('[agentdeck] OpenClaw Gateway connected');
+                        settleGatewayInstability(Date.now());
                         if (core.stateMachine.getSnapshot().state === 'disconnected') {
                             core.stateMachine.handleHookEvent('SessionStart', {});
                         }
@@ -4541,6 +4787,11 @@ export async function startDaemon(opts) {
                         log('[agentdeck] OpenClaw Gateway disconnected');
                         core.stateMachine.emit('state_changed', core.stateMachine.getSnapshot());
                         core.broadcastSessionsList().catch(() => { });
+                        const flapAt = Date.now();
+                        gatewayFlaps.record(flapAt);
+                        assessGatewayInstability(flapAt).catch((err) => {
+                            debug('Gateway', `instability assessment failed: ${String(err)}`);
+                        });
                     }
                     break;
                 }
@@ -6254,12 +6505,49 @@ export async function startDaemon(opts) {
             };
             core.broadcast(evalEvent);
         });
+        let judgeReprobeInFlight = false;
         const apmeEvalTimer = setInterval(() => {
             // 1. Enqueue unevaluated runs for deterministic + judge
             const pending = apme.store.listUnevaluatedRuns(5);
             for (const run of pending) {
                 apme.runner.enqueue({ runId: run.id, projectPath: run.projectPath ?? undefined });
             }
+            // 1b. Drain the TASK judge backlog: closed, unjudged, not declined.
+            //     A task's one judge call fires from the collector's close path, so
+            //     a daemon restart mid-eval, an offline judge, or a backend probe
+            //     not yet ready lost it for good — 1,060 closed tasks had piled up
+            //     unjudged (2026-09-03). Batched small (the judge is a local model
+            //     answering one prompt at a time) and only while the judge is
+            //     actually reachable, so an outage does not turn into a retry storm.
+            //     Bounded to 30 days: older rows predate response capture and would
+            //     mostly be declined anyway.
+            //     One at a time, and only when nothing is already at the judge:
+            //     the local backends answer serially, so three per tick queued
+            //     past the call timeout, burned every task's attempts, and parked
+            //     the whole backlog (289 tasks, 2026-09-03). The live close path
+            //     still enqueues on its own; the drain yields to it.
+            const probe = apme.runner.lastBackendProbe;
+            if (probe && probe.status !== 'ready' && Date.now() - probe.checkedAt >= APME_JUDGE_REPROBE_MS && !judgeReprobeInFlight) {
+                judgeReprobeInFlight = true;
+                void apme.runner.refreshBackendProbe(loadApmeConfig().judge).then((status) => {
+                    if (status.status === 'ready') {
+                        log(`[agentdeck] APME judge ready again: ${status.backend}${status.model ? ` (${status.model})` : ''} — the task backlog resumes`);
+                    }
+                }).catch(() => { }).finally(() => { judgeReprobeInFlight = false; });
+            }
+            if (probe?.status === 'ready' && apme.runner.inFlightTaskEvals === 0) {
+                // The backlog query cannot see a park, so ask for a WINDOW and let
+                // `pickBacklogTasks` choose. Asking for one row fed the head of
+                // `ended_at DESC` and nothing else: a task whose judge call fails
+                // every attempt owns that head, and `enqueueTask` drops a parked task
+                // silently, so every tick spent its one slot on it and the backlog
+                // behind it starved (156 tasks, 2026-08-07..23, measured 2026-09-06).
+                // Still one task per tick — the window only decides WHICH one.
+                const backlog = apme.store.listTasksNeedingSummary(APME_TASK_JUDGE_DRAIN_WINDOW, Date.now() - 30 * 86_400_000);
+                for (const t of apme.runner.pickBacklogTasks(backlog, APME_TASK_JUDGE_DRAIN_PER_TICK)) {
+                    apme.runner.enqueueTask({ runId: t.runId, taskId: t.id, ...(t.taskCategory ? { category: t.taskCategory } : {}) });
+                }
+            }
             // 2. Run outcome detection + composite scoring on recently closed runs
             // that don't have an outcome yet.
             const closedRuns = apme.store.listRuns({ limit: 20 });
@@ -6321,26 +6609,29 @@ export async function startDaemon(opts) {
             //    Batched small: `enqueueTask` dispatches immediately with no
             //    concurrency cap, so a backlog is drained a few per tick rather than
             //    fired at the judge all at once.
+            //    Since `rehydrateOpenRuns` (2026-09-03) a restart no longer feeds
+            //    this path — the new daemon adopts the open runs — so what reaches
+            //    it is a run nobody resumed: a session bridge that died, or a
+            //    daemon that was down for longer than the stale window.
             const abandoned = apme.store.listAbandonedRuns(APME_ABANDONED_RUN_STALE_SEC, 5);
             for (const run of abandoned) {
                 if (apme.collector.isLiveRun(run.id))
                     continue; // still owned by us
                 const closedTasks = apme.store.reapAbandonedRun(run.id, run.lastActivity);
+                // A run adopted at startup whose session never spoke is reapable
+                // (see `isLiveRun`), and its in-memory edges must go with the row.
+                apme.collector.releaseRun(run.id);
                 for (const task of closedTasks) {
-                    // Judge only what there is something to judge. The backlog this
-                    // reaper drains predates the response-capture fix, so most of those
-                    // tasks hold prompts and tool calls but no reply — scoring them would
-                    // push hundreds of "judged against silence" rows into the scorecard,
-                    // the same noise `response_kind` exists to keep out. Closing the row
-                    // is the data-hygiene win; the eval is a bonus when it can be earned.
-                    const hasReply = apme.store.listTurnsForTask(task.id)
-                        .some((t) => typeof t.response === 'string' && t.response.trim().length > 0);
-                    if (!hasReply)
+                    // Judge only what there is something to judge — the one rule in
+                    // task-gradeability.ts, which the runner applies again and which
+                    // also stamps the reason on the row. Closing the row is the
+                    // data-hygiene win; the eval is a bonus when it can be earned.
+                    if (!taskGradeability(apme.store.listTurnsForTask(task.id)).gradeable)
                         continue;
                     apme.runner.enqueueTask({
                         runId: run.id, taskId: task.id,
                         ...(task.category ? { category: task.category } : {}),
-                        boundarySignal: 'orphaned',
+                        boundarySignal: task.boundarySignal,
                     });
                 }
                 debug('APME', `reaped abandoned run ${run.id.slice(0, 8)} — ${closedTasks.length} task(s) closed`);
@@ -6423,6 +6714,10 @@ export async function startDaemon(opts) {
         // would keep firing self-POSTs at a port this daemon no longer owns.
         observedStopWatchdogs.stop();
         voiceAssistant?.stop();
+        // A recovery turn in flight is a `claude` child whose own timeout dies with
+        // this process; ending it here is the difference between a bounded 25s
+        // request and an orphan.
+        stopClaudeUsageRecoveryChildren();
         bridgeLogStream.stop();
         // Flush synchronously — the process exits a few lines below and a pending
         // debounce timer would take the last turn's entries with it.