@agentdeck/bridge 1.0.5 → 1.0.7

package/dist/daemon-server.js

@@ -46,6 +46,13 @@ const OBSERVED_APPROVAL_ENABLED = process.env.AGENTDECK_OBSERVED_APPROVAL !== '0
  *  call to Claude's own permission flow. Must stay well under the hook curl's
  *  --max-time 60 so the release reaches Claude before curl gives up. */
 const OBSERVED_APPROVAL_HOLD_MS = Math.min(50_000, Math.max(5_000, Number(process.env.AGENTDECK_APPROVAL_HOLD_MS) || 25_000));
+/** Inactivity after which an unclosed APME run is treated as abandoned and
+ *  finalized. Deliberately generous: an orphan stays reapable forever, so
+ *  closing it late costs nothing, while reaping a live run corrupts the unit
+ *  being measured. Session bridges own their own collector state and are
+ *  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);
 import { VoiceManager } from './voice.js';
 import { VoiceAssistantManager } from './voice-assistant.js';
 import { listActive as listActiveSessions, findAvailablePort, findExistingDaemon, DAEMON_DEFAULT_PORT, probeDaemonHealth, requestDaemonShutdown, scanDaemonPortWindow, shouldConcedePortToOccupant, waitForDaemonExit, writeDaemonInfo, ensureDaemonInfo, removeDaemonInfo, readDaemonInfo, removeDaemonSession, getCandidateDataDirs, getOwnTimelineFile, } from './session-registry.js';
@@ -64,7 +71,7 @@ import { FallbackTaskTimeline } from './fallback-task-timeline.js';
 import { handleApmeRequest } from './apme/http.js';
 import { readModelFromTranscript } from './apme/claude-transcript-reader.js';
 import { transcriptTimelineForSession, lastAssistantTextFromTranscript, lastAssistantTextForSession, } from './session-transcript-timeline.js';
-import { DeviceVoiceReplyRouter, speakableReply, pcmFromWav, } from './device-voice-reply.js';
+import { DeviceVoiceReplyRouter, speakableReply, spokenDigest, pcmFromWav, } from './device-voice-reply.js';
 import { rawSessionId } from '@agentdeck/shared';
 import { lastAgentMessageFromCodexRollout } from './codex-rollout-response.js';
 import { callFoundationModelsHelper } from './foundation-models-helper.js';
@@ -75,7 +82,7 @@ import { getConnectedAdbDevices, hasAdb, getAdbDeviceCount } from './adb-reverse
 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 } from './openclaw-session.js';
+import { injectOpenClawSession, OPENCLAW_SESSION_ID } from './openclaw-session.js';
 import { buildCardFeed, buildGlance, applyOutboxDecisions, FeedPullTracker, formatFeedPull, normalizeClientIp, parsePullTelemetry, } from './card-feed.js';
 import { threadModule } from './card-modules.js';
 import { AutonomousPocketEngine, createAutonomousPocketModules, parsePocketAutonomyConfig, } from './pocket-autonomy.js';
@@ -788,8 +795,16 @@ function buildNodeModuleHealth(startedModules) {
         modules.timebox = timebox.statusSnapshot();
     }
     else if (configuredTimebox.length > 0) {
+        // Configured but the module never started — say so explicitly. An omitted
+        // `connected` reads as "no information" to retain-on-absent clients, and a
+        // panel nobody is driving must not inherit a stale connected:true.
         modules.timebox = {
             configuredDeviceCount: configuredTimebox.length,
+            connected: false,
+            statusReason: 'sync module not started',
+            displayDimmed: false,
+            hasFrame: false,
+            lastError: null,
             devices: configuredTimebox.map((d) => ({
                 address: d.address,
                 name: d.name ?? 'Timebox Mini',
@@ -803,8 +818,14 @@ function buildNodeModuleHealth(startedModules) {
         modules.idotmatrix = idotmatrix.statusSnapshot();
     }
     else if (configuredIDotMatrix.length > 0) {
+        // Configured but the module never started — see the Timebox note above.
         modules.idotmatrix = {
             configuredDeviceCount: configuredIDotMatrix.length,
+            connected: false,
+            statusReason: 'sync module not started',
+            displayDimmed: false,
+            hasFrame: false,
+            lastError: null,
             devices: configuredIDotMatrix.map((d) => ({
                 address: d.address,
                 name: d.name ?? 'iDotMatrix',
@@ -983,6 +1004,22 @@ export async function startDaemon(opts) {
     // `gatewaySessionState` / `gatewayModelName` dedicated fields.
     let gatewaySessionState = 'idle';
     let gatewayModelName;
+    /**
+     * Snapshot for an `openclaw` state event: the global machine with the
+     * Gateway-local model pinned back on.
+     *
+     * The Gateway's `model_info` no longer writes `core.stateMachine` (see the
+     * parser branch): that machine is fed by every observed Claude/Codex/OpenCode
+     * hook, and the hub stamps its broadcasts with the user's focused session —
+     * so a model written there by a *different* agent is read as the focused
+     * session's own. That is how `GLM-5.2 (1M)` appeared as the model of a Claude
+     * session on both decks. Keeping the model out of the shared slot means the
+     * Gateway's own events have to carry it explicitly, which is what this does.
+     */
+    const gatewaySnapshot = (base) => ({
+        ...(base ?? core.stateMachine.getSnapshot()),
+        modelName: gatewayModelName ?? null,
+    });
     // Wi-Fi WebSocket e-ink panels (XTeink X3/X4 CrossPoint fork) self-register
     // their device roster via `client_register{clientType:"eink-device"}` — the
     // same volunteer model as the Stream Deck plugin. This handler lived ONLY in
@@ -1982,6 +2019,27 @@ export async function startDaemon(opts) {
                     const respRaw = responseText.length > 0
                         ? cleanRawText(responseText.length > 200 ? responseText.slice(0, 197) + '...' : responseText)
                         : '';
+                    // APME: the text below is the assistant half of the turn — hand it to
+                    // the collector on the SAME branch that decides the timeline row.
+                    // `setTurnResponse` was reachable only from the PTY session bridge
+                    // (bridge/src/index.ts), which hook-observed sessions (direct
+                    // `claude` / `codex` / standalone `opencode`) never go through, so
+                    // every such turn archived a prompt and its tool calls but no reply:
+                    // `turns.response` stayed NULL and no `assistant_message` trajectory
+                    // event was ever written. The dashboard therefore could not replay a
+                    // conversation the timeline shows in full, and the judge scored those
+                    // turns against silence. Empty text is still worth recording — it
+                    // tags `response_kind` tool_only/empty so the runner skips judging.
+                    if (apme) {
+                        if (turnOpen)
+                            apme.collector.setTurnResponse(hookSid, responseText);
+                        else if (responseText.length > 0) {
+                            // No open turn: a missed prompt hook or a late/duplicate stop.
+                            // The last-closed fallback refuses to overwrite an existing
+                            // response, so a duplicate stop is a no-op instead of a clobber.
+                            apme.collector.setLastClosedTurnResponse(hookSid, responseText);
+                        }
+                    }
                     if (turnOpen && lastStart) {
                         const now = Date.now();
                         const taskId = (apme
@@ -2475,6 +2533,24 @@ export async function startDaemon(opts) {
     core.wireDisplayMonitor();
     let lastStateEvent = null;
     let userFocusedSessionId = null;
+    /**
+     * Stamp the focused session onto a hub `state_update`.
+     *
+     * This field carries two jobs, and both are load-bearing, which is why it
+     * cannot simply be narrowed:
+     *  - attribution: `buildStateEvent` sets no `sessionId` at all, so a
+     *    hook-observed session's AWAITING_PERMISSION options reach the decks
+     *    attributed only by this field (see session-deck-awaiting tests).
+     *  - focus ack: the Apple app toggles creature focus against it and needs it
+     *    even for a session that emits nothing of its own.
+     *
+     * The consequence is a standing invariant on the payload: whatever rides along
+     * here is read as the focused session's own. So nothing may write a *different*
+     * agent's per-session field into `core.stateMachine` — the Gateway's model went
+     * in and came out as a Claude session's model. Gateway-specific state lives in
+     * `gatewaySessionState` / `gatewayModelName` and is re-attached by
+     * `gatewaySnapshot()`.
+     */
     const attachFocusedSessionId = (event) => {
         if (event.type !== 'state_update')
             return event;
@@ -2483,6 +2559,28 @@ export async function startDaemon(opts) {
             focusedSessionId: userFocusedSessionId ?? '',
         };
     };
+    /**
+     * Stamp a *Gateway-specific* state event — one whose payload really is the
+     * Gateway's (its parser events, its connection transitions), as opposed to the
+     * hub broadcasts above that merely get labelled `openclaw` while the Gateway is
+     * alive.
+     *
+     * These name their own row (`sessionId`), which is the honest attribution and
+     * the reason a client never has to guess: an event carrying the Gateway's model
+     * now says so. The focus ack rides only when the Gateway IS the focused row —
+     * otherwise this event would claim to describe a Claude session, which is
+     * precisely how `GLM-5.2 (1M)` became that session's model on both decks. The
+     * ack still reaches the Apple app through every hub broadcast.
+     */
+    const attachGatewayEvent = (event) => {
+        if (event.type !== 'state_update')
+            return event;
+        return {
+            ...event,
+            sessionId: OPENCLAW_SESSION_ID,
+            focusedSessionId: userFocusedSessionId === OPENCLAW_SESSION_ID ? OPENCLAW_SESSION_ID : '',
+        };
+    };
     const broadcastFocusedState = () => {
         const gwAlive = gatewayAdapter?.isAlive() ?? false;
         const stateEvent = attachFocusedSessionId(core.buildStateEvent({
@@ -2932,7 +3030,14 @@ export async function startDaemon(opts) {
                         core.stateMachine.handleHookEvent('SessionEnd', {});
                     break;
                 case 'parser':
-                    core.stateMachine.handleParserEvent(evt.event, evt.data);
+                    // `model_info` is deliberately NOT forwarded: the global machine holds
+                    // one modelName for the whole hub, fed by every observed hook session,
+                    // and its broadcasts are stamped with the user's focused session — so a
+                    // model written here by the Gateway is read as that session's own
+                    // (GLM on a Claude row). It lives in `gatewayModelName` instead, and
+                    // `gatewaySnapshot()` puts it back on the Gateway's own events.
+                    if (evt.event !== 'model_info')
+                        core.stateMachine.handleParserEvent(evt.event, evt.data);
                     // Gateway-local activity state for the virtual session row (mirror of
                     // Swift `gatewaySessionState`). Kept separate from the global
                     // `core.stateMachine` above so the OpenClaw row reflects only the
@@ -2961,10 +3066,10 @@ export async function startDaemon(opts) {
                         if (models) {
                             core.cachedModelCatalog = models;
                             const snap = core.stateMachine.getSnapshot();
-                            const stateEvent = attachFocusedSessionId(core.buildStateEvent({
+                            const stateEvent = attachGatewayEvent(core.buildStateEvent({
                                 agentType: 'openclaw',
                                 agentCapabilities: OPENCLAW_CAPABILITIES,
-                                snapshot: snap,
+                                snapshot: gatewaySnapshot(snap),
                             }));
                             lastStateEvent = stateEvent;
                             core.broadcast(stateEvent);
@@ -3017,10 +3122,10 @@ export async function startDaemon(opts) {
                         }
                         // Force full state broadcast
                         const snap = core.stateMachine.getSnapshot();
-                        const gwStateEvent = attachFocusedSessionId(core.buildStateEvent({
+                        const gwStateEvent = attachGatewayEvent(core.buildStateEvent({
                             agentType: 'openclaw',
                             agentCapabilities: OPENCLAW_CAPABILITIES,
-                            snapshot: snap,
+                            snapshot: gatewaySnapshot(snap),
                         }));
                         lastStateEvent = gwStateEvent;
                         core.wsServer.broadcast(gwStateEvent);
@@ -3434,10 +3539,10 @@ export async function startDaemon(opts) {
             if (target === 'openclaw' && gatewayAdapter?.isAlive()) {
                 // Force broadcast OpenClaw state to all clients
                 const snap = core.stateMachine.getSnapshot();
-                const gwStateEvent = attachFocusedSessionId(core.buildStateEvent({
+                const gwStateEvent = attachGatewayEvent(core.buildStateEvent({
                     agentType: 'openclaw',
                     agentCapabilities: OPENCLAW_CAPABILITIES,
-                    snapshot: snap,
+                    snapshot: gatewaySnapshot(snap),
                 }));
                 lastStateEvent = gwStateEvent;
                 core.wsServer.broadcast(gwStateEvent);
@@ -3799,7 +3904,18 @@ export async function startDaemon(opts) {
         const voiceCfg = loadDaemonSettings().voice;
         if (voiceCfg?.speakReplies === false)
             return; // opt-out, default on
-        const spoken = speakableReply(text);
+        // Speech gets the lead, not the transcript: an explicit summary line if the
+        // answer has one, else its first sentence. The full answer is already on the
+        // screen the user is sitting at, where it can be skimmed — read aloud it is
+        // a minute of monologue nobody can skip. `voice.speakFullReply` opts back in.
+        const full = voiceCfg?.speakFullReply === true;
+        const spoken = spokenDigest(text, { full });
+        if (!full) {
+            const readable = speakableReply(text, Number.MAX_SAFE_INTEGER);
+            if (spoken && readable.length > spoken.length) {
+                log(`[agentdeck] voice: reply digested ${readable.length} -> ${spoken.length} chars`);
+            }
+        }
         if (!spoken) {
             // A code-only answer has nothing worth reading aloud; say that instead of
             // spelling out punctuation, so the user still knows the turn finished.
@@ -4649,6 +4765,43 @@ export async function startDaemon(opts) {
             for (const id of orphans) {
                 apme.store.updateRun(id, { endedAt: Date.now(), taskCategory: '_empty' });
             }
+            // 5. Reap ABANDONED runs — the ones step 4 cannot see. A daemon restart
+            //    (or crash) drops the in-memory session→run map, so every run that
+            //    was mid-session is left with ended_at NULL forever. Those carry real
+            //    prompts and turns, so they fail step 4's empty-shell predicate, and
+            //    because their TASK also never closes they are never evaluated: the
+            //    store had accumulated 65 open tasks against 9 closed ones.
+            //    Closing the run makes step 1 pick it up next tick; the task eval has
+            //    to be enqueued here, since its normal trigger (`onTaskClosed`) fires
+            //    from the collector's in-memory close path, which is exactly what
+            //    went missing.
+            //    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.
+            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);
+                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)
+                        continue;
+                    apme.runner.enqueueTask({
+                        runId: run.id, taskId: task.id,
+                        ...(task.category ? { category: task.category } : {}),
+                        boundarySignal: 'orphaned',
+                    });
+                }
+                debug('APME', `reaped abandoned run ${run.id.slice(0, 8)} — ${closedTasks.length} task(s) closed`);
+            }
         }, 30_000); // every 30s
         core.addInterval(apmeEvalTimer);
     }