@adhdev/daemon-core 0.9.82-rc.376 → 0.9.82-rc.378

package/src/mesh/mesh-runtime-store.ts

@@ -152,21 +152,6 @@ export class MeshRuntimeStore {
                 expires_at INTEGER NOT NULL
             );
 
-            -- R3: idempotent coordinator inbox. When a terminal/force-inject event is
-            -- direct-injected into a LIVE local CLI coordinator (coord.onEvent('send_message')),
-            -- we record (coordinator_daemon_id, fingerprint) here. That same coordinator also
-            -- polls get_pending_mesh_events, which would re-deliver the queued copy of the very
-            -- event it just received in its PTY → user sees the completion twice. The drain for
-            -- a coordinator daemon filters out events already direct-delivered to it, giving
-            -- exactly-once-per-coordinator while keeping the queue for other consumers (idle /
-            -- MCP-only / remote) that did NOT receive the direct inject.
-            CREATE TABLE IF NOT EXISTS mesh_direct_delivered_events (
-                coordinator_daemon_id TEXT NOT NULL,
-                fingerprint TEXT NOT NULL,
-                expires_at INTEGER NOT NULL,
-                PRIMARY KEY (coordinator_daemon_id, fingerprint)
-            );
-
             CREATE TABLE IF NOT EXISTS mesh_direct_dispatches (
                 task_id TEXT PRIMARY KEY,
                 mesh_id TEXT NOT NULL,
@@ -342,28 +327,6 @@ export class MeshRuntimeStore {
         this.db.prepare('DELETE FROM mesh_completion_fingerprints WHERE expires_at <= ?').run(Date.now());
     }
 
-    // R3: record that an event (by pending-event fingerprint) was direct-injected into a live
-    // coordinator on the given daemon, so that coordinator's own drain skips the queued copy.
-    recordDirectDelivered(coordinatorDaemonId: string, fingerprint: string, ttlMs: number): void {
-        if (!coordinatorDaemonId || !fingerprint) return;
-        this.db.prepare(
-            'INSERT OR REPLACE INTO mesh_direct_delivered_events (coordinator_daemon_id, fingerprint, expires_at) VALUES (?, ?, ?)'
-        ).run(coordinatorDaemonId, fingerprint, Date.now() + ttlMs);
-        this.maybeCheckpointWal();
-    }
-
-    wasDirectDelivered(coordinatorDaemonId: string, fingerprint: string): boolean {
-        if (!coordinatorDaemonId || !fingerprint) return false;
-        const row = this.db.prepare(
-            'SELECT 1 FROM mesh_direct_delivered_events WHERE coordinator_daemon_id = ? AND fingerprint = ? AND expires_at > ?'
-        ).get(coordinatorDaemonId, fingerprint, Date.now());
-        return row !== undefined;
-    }
-
-    sweepExpiredDirectDelivered(): void {
-        this.db.prepare('DELETE FROM mesh_direct_delivered_events WHERE expires_at <= ?').run(Date.now());
-    }
-
     private maybeCheckpointWal(): void {
         if (++this.walWriteCounter < MeshRuntimeStore.WAL_CHECK_INTERVAL) return;
         this.walWriteCounter = 0;

package/src/providers/cli-provider-instance.ts

@@ -81,6 +81,14 @@ type CompletedFinalizationBlock = {
     reason: string;
     terminal?: boolean;
     allowTimeout?: boolean;
+    // (SETTLE-VALLEY) When set, suppress the CANON-C decoupled-immediate emit for this
+    // missing_final_assistant block and HOLD (retry up to COMPLETED_FINALIZATION_MAX_WAIT_MS)
+    // until the native transcript's final assistant turn arrives (block clears → genuine emit)
+    // or the worker resumes (resume guard cancels). Set only for the inter-approval idle valley
+    // of a native-history mesh worker, where an immediate weak emit would freeze a truncated
+    // preamble summary (evidenceLevel=insufficient) into the append-only ledger before the
+    // worker's next approval turn resumes. Independent of valley length.
+    holdForTranscript?: boolean;
 };
 
 type CompletionFinalAssistantEvidence = {
@@ -113,7 +121,13 @@ const COMPLETED_FINALIZATION_MAX_WAIT_MS = 30_000;
 // agent picking the turn back up. A short non-zero settle window restores that resume guard for
 // mesh workers without delaying genuinely-finished turns beyond this bound. Scoped to mesh
 // worker sessions so interactive native-history sessions keep the immediate flush.
-const NATIVE_HISTORY_MESH_IDLE_SETTLE_MS = 1500;
+// 4000ms (was 1500): live measurement showed the completion event can fire 1.6–3s
+// BEFORE the worker's final-assistant turn lands in the transcript on a natural
+// generating→idle completion (no approval modal), freezing a prior intermediate
+// bubble as finalSummary (evidenceLevel=insufficient). The 68a3c324 waiting_approval
+// hold only covers the approval-resolved valley; widening this settle window to 4000ms
+// covers that race AND the ~3s waiting_approval valley within the settle bound.
+const NATIVE_HISTORY_MESH_IDLE_SETTLE_MS = 4000;
 // TASKBUBBLE-DUP: window during which an identical user-input ack (same trimmed
 // content on the same instance) is treated as a redelivery of one dispatch and
 // suppressed from the chat transcript. Matches the coordinator-side
@@ -1441,6 +1455,22 @@ export class CliProviderInstance implements ProviderInstance {
                     if (this.type === 'antigravity-cli') {
                         return null;
                     }
+                    // (SETTLE-VALLEY) The inter-approval idle valley: a native-history mesh worker
+                    // that resolved an approval and fell briefly idle (waiting_approval→idle) BEFORE
+                    // the next approval turn resumes. The live valley (~3s) is mostly covered by the
+                    // 4000ms NATIVE_HISTORY_MESH_IDLE_SETTLE_MS settle window, but a longer valley can
+                    // still let the flush run while the transcript's final assistant turn is not yet
+                    // written (source still the screen parse → finalAssistantPresent=false,
+                    // workerResult.source='default'). CANON-C would emit immediately here, freezing a
+                    // truncated preamble summary as evidenceLevel=insufficient. Instead HOLD: this
+                    // waiting_approval hold complements the settle window. Retry until the transcript finalizes
+                    // (block clears → genuine emit) or the worker resumes (resume guard cancels),
+                    // bounded by COMPLETED_FINALIZATION_MAX_WAIT_MS. Scoped to the approval-resolved
+                    // idle so a genuinely-finished background-child turn keeps the CANON-C immediate
+                    // emit (its transcript trails by a write, not by a whole resume).
+                    if (allowMissingAssistantTimeout && pending.previousStatus === 'waiting_approval') {
+                        return { reason: 'missing_final_assistant', terminal: false, holdForTranscript: true };
+                    }
                     return { reason: 'missing_final_assistant', terminal: true, allowTimeout: allowMissingAssistantTimeout };
                 }
                 if ((this.provider as any).requiresFinalAssistantBeforeIdle === true) {
@@ -1585,6 +1615,15 @@ export class CliProviderInstance implements ProviderInstance {
             // one still surfaces, and isFalseIdleCompletion keeps the direct dispatch active until
             // then). All OTHER blocks (genuinely-busy adapter/partial/parsed states, transient
             // parse_error) keep the existing terminal-hold / 30s-retry behavior unchanged.
+            //
+            // (SETTLE-VALLEY) Exception: a `holdForTranscript` block is the inter-approval idle
+            // valley of a native-history mesh worker (waiting_approval→idle that will resume into
+            // the next approval). It deliberately does NOT carry allowTimeout, so it falls into the
+            // hold-and-retry path below (terminal:false) rather than the CANON-C immediate emit —
+            // the retry loop re-runs the resume guard each cycle, so when the worker resumes the
+            // pending completion is cancelled, and when the transcript's final assistant arrives the
+            // block clears for a GENUINE emit. This blocks the truncated weak (insufficient) summary
+            // from ever being emitted during the valley, without depending on the valley's length.
             const isTranscriptEvidenceGate = block.allowTimeout === true;
             LOG.debug('CLI', `[${this.type}] finalization block: reason=${blockReason} terminal=${block.terminal} allowTimeout=${isTranscriptEvidenceGate} waitedMs=${waitedMs} maxWait=${COMPLETED_FINALIZATION_MAX_WAIT_MS}`);
             if (!isTranscriptEvidenceGate && (block.terminal || waitedMs < COMPLETED_FINALIZATION_MAX_WAIT_MS)) {

package/src/providers/native-history/constants.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared constants for the native-history subtree.
+ *
+ * OSS code (AGPL-3.0). Must not import from packages/ (proprietary).
+ */
+'use strict';
+
+/**
+ * Spawn-bind grace window: an on-disk rollout whose session_meta.timestamp
+ * lands within ±SPAWN_BIND_GRACE_MS of the daemon's spawnedAtMs is treated
+ * as belonging to that daemon session. 10s is long enough to absorb codex
+ * binary startup latency on cold caches and short enough that two
+ * back-to-back launches don't both fall inside the same window.
+ *
+ * Shared by the declarative executor (providers/spec/native-history-executor.ts)
+ * and the codex runtime disambiguator (providers/native-history/dispatcher.ts) —
+ * both apply the identical ±10s session-binding window.
+ */
+export const SPAWN_BIND_GRACE_MS = 10_000;

package/src/providers/native-history/dispatcher.ts

@@ -18,6 +18,7 @@ import { readSession as readClaudeCliSession } from './claude-cli-transcript.js'
 import { readSession as readCodexCliSession } from './codex-cli-transcript.js';
 import { readSession as readAntigravityCliSession } from './antigravity-cli-transcript.js';
 import { readSession as readHermesCliSession } from './hermes-cli-transcript.js';
+import { SPAWN_BIND_GRACE_MS } from './constants.js';
 
 export type ReaderId = 'claude-cli' | 'codex-cli' | 'antigravity-cli' | 'hermes-cli';
 
@@ -153,8 +154,6 @@ function findCodexPathBySessionId(root: string, sessionId: string): string | nul
     return matches[0]?.p ?? null;
 }
 
-const CODEX_SPAWN_BIND_GRACE_MS = 10_000;
-
 function findCodexPathByRuntime(root: string, workspace: string, sessionStartedAtMs: number): string | null {
     if (!fs.existsSync(root) || !workspace) return null;
     const workspaceResolved = resolveRealPath(workspace);
@@ -180,7 +179,7 @@ function findCodexPathByRuntime(root: string, workspace: string, sessionStartedA
             const diff = sessionStartedAtMs > 0 && meta.timestampMs != null
                 ? Math.abs(meta.timestampMs - sessionStartedAtMs)
                 : 0;
-            if (sessionStartedAtMs > 0 && (meta.timestampMs == null || diff > CODEX_SPAWN_BIND_GRACE_MS)) continue;
+            if (sessionStartedAtMs > 0 && (meta.timestampMs == null || diff > SPAWN_BIND_GRACE_MS)) continue;
             matches.push({ p: entryPath, mtime, diff });
         }
     }

package/src/providers/spec/native-history-executor.ts

@@ -30,6 +30,7 @@ import type {
     NativeHistorySqliteSource,
     NativeHistoryToolMap,
 } from './types.js';
+import { SPAWN_BIND_GRACE_MS } from '../native-history/constants.js';
 
 export interface NativeHistoryInput {
     agentType?: string;
@@ -707,15 +708,6 @@ function readCandidateSessionMeta(filePath: string): CandidateMeta | null {
     }
 }
 
-/**
- * Spawn-bind grace window: an on-disk rollout whose session_meta.timestamp
- * lands within ±SPAWN_BIND_GRACE_MS of the daemon's spawnedAtMs is treated
- * as belonging to that daemon session. 10s is long enough to absorb codex
- * binary startup latency on cold caches and short enough that two
- * back-to-back launches don't both fall inside the same window.
- */
-const SPAWN_BIND_GRACE_MS = 10_000;
-
 function pickBoundFromEntries(
     candidatePaths: string[],
     sessionFloorMs: number,

package/src/runtime-defaults.ts

@@ -14,3 +14,42 @@ export const DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS = 10_000;
 export const DEFAULT_SESSION_HOST_READY_TIMEOUT_MS = 15_000;
 
 export const STANDALONE_CDP_SCAN_INTERVAL_MS = 15_000;
+
+// ---------------------------------------------------------------------------
+// Mesh P2P timeout windows (env-overridable)
+// ---------------------------------------------------------------------------
+
+// Reads a mesh timeout (ms) from the first non-empty env var in `names`, clamped
+// to [1_000, 120_000]; falls back to `defaultMs` when none is set or the value is
+// out of range. The clamp lets a slow real link be tuned up (TURN-relayed peers
+// whose RTT is many seconds) and lets the test harness shrink the window to its
+// 1s minimum, without ever degenerating to 0 or an absurd value. Multiple names
+// are accepted so a renamed constant can keep honoring a legacy alias.
+export function readMeshTimeoutEnvMs(names: string | string[], defaultMs: number): number {
+    const candidates = Array.isArray(names) ? names : [names];
+    for (const name of candidates) {
+        const raw = process.env[name]?.trim();
+        if (!raw) continue;
+        const parsed = Number.parseInt(raw, 10);
+        if (Number.isFinite(parsed) && parsed >= 1_000 && parsed <= 120_000) return parsed;
+        return defaultMs;
+    }
+    return defaultMs;
+}
+
+// SINGLE source of truth for the mesh cold-open *connect* budget — the time a
+// caller grants a peer whose mesh DataChannel is not open yet to drive the
+// cross-machine (often TURN-relayed) ICE/DTLS handshake before the response
+// deadline takes over. Two call sites share this so an env override tunes BOTH:
+//   - commands/router.ts direct-peer git_status probe (requireDirectPeerTruth)
+//   - mesh/mesh-events-coordinator.ts remote task-dispatch (deliverTaskToSession)
+// Before unification the coordinator hard-coded 45_000 while the router was
+// env-overridable, so setting the env tuned the probe path but silently left the
+// dispatch path at 45s — the same nominal 45s, but divergent the moment the env
+// was set. Matches the daemon-cloud DaemonMeshManager CONNECT_TIMEOUT_MS (45s).
+// `MESH_DIRECT_PROBE_CONNECT_TIMEOUT_MS` is honored as a backward-compat alias so
+// environments already tuned under the old name keep working.
+export const MESH_CONNECT_TIMEOUT_MS = readMeshTimeoutEnvMs(
+    ['MESH_CONNECT_TIMEOUT_MS', 'MESH_DIRECT_PROBE_CONNECT_TIMEOUT_MS'],
+    45_000,
+);