@adhdev/daemon-core 0.9.82-rc.445 → 0.9.82-rc.446

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.445",
+  "version": "0.9.82-rc.446",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.445",
+    "@adhdev/mesh-shared": "0.9.82-rc.446",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

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

@@ -2564,28 +2564,91 @@ export class CliProviderInstance implements ProviderInstance {
                     if (shortFinalSummary) {
                         this.pushEvent({ event: 'agent:generating_started', chatTitle, timestamp: now - shortDurationMs });
                     }
+                    // FALSE-IDLE short-gen settle: snapshot the producing turn's start + taskId NOW,
+                    // before `generatingStartedAt` is reset below — the settle-arm path (mesh sessions,
+                    // see the mesh branch further down) needs the same turn anchor the normal
+                    // completedDebounce branch captures, and generatingStartedAt is the fallback for it.
+                    const shortEngineTurnStart = typeof (this.adapter as any)?.currentTurnStartedAt === 'number'
+                        && Number.isFinite((this.adapter as any).currentTurnStartedAt)
+                        ? (this.adapter as any).currentTurnStartedAt as number
+                        : 0;
+                    const shortTurnStartedAt = shortEngineTurnStart || this.generatingStartedAt || 0;
+                    const shortTaskId = this.completingTurnTaskId();
                     this.generatingDebouncePending = null;
                     this.generatingStartedAt = 0;
-                    const missingEvidence = ((this.provider as any).requiresFinalAssistantBeforeIdle === true || shortEvidenceSource === 'external-native') && !shortFinalSummary;
+                    // FALSE-IDLE short-gen: a short-generating completion with NO transcript
+                    // backing at all (shortEvidenceSource === 'unavailable': both the screen parse
+                    // AND the external-native transcript failed to yield a final assistant) is just
+                    // as unproven as an 'external-native' source that returned no final assistant.
+                    // Fold 'unavailable' into the missing-evidence predicate so a zero-evidence dip
+                    // (the mid-turn point-sample that triggered this whole false-idle bug) is treated
+                    // as weak/held, not fired as a genuine completion. A real shortFinalSummary being
+                    // present still clears the gate (the !shortFinalSummary guard is unchanged).
+                    const missingEvidence = ((this.provider as any).requiresFinalAssistantBeforeIdle === true
+                        || shortEvidenceSource === 'external-native'
+                        || shortEvidenceSource === 'unavailable') && !shortFinalSummary;
                     if (missingEvidence) {
                         LOG.warn('CLI', `[${this.type}] short completion missing final assistant evidence (source=${shortEvidenceSource})`);
                     }
-                    // When evidence is missing and there is no active mesh task context, suppress
-                    // the completion event. Providers with requiresFinalAssistantBeforeIdle or
-                    // external-native history must confirm a final assistant message before the
-                    // coordinator records task_completed. Only emit here if a mesh task is active
-                    // so the coordinator can apply its own timeout/retry logic.
-                    const hasMeshContext = !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.launchedByCoordinator);
-                    if (missingEvidence && !hasMeshContext) {
-                        LOG.info('CLI', `[${this.type}] short completion suppressed: missing final assistant evidence, no mesh context (source=${shortEvidenceSource})`);
-                        // completedDebouncePending intentionally left null — the session is now idle
-                        // with no confirmed turn, matching the startup-blip suppression semantics.
-                        // (No EvtTrace: not a mesh session, so nothing routes to a coordinator.)
-                    } else {
-                        // EVTTRACE: completion fired (short-generating idle path).
+                    if (this.isAutonomousMeshSession()) {
+                        // FALSE-IDLE short-gen settle (the core fix): for an autonomously-progressing
+                        // mesh session (delegated worker OR self-coordinator), the short-generating
+                        // branch was a POINT-SAMPLE — a single idle read from getStatus({allowParse:false})
+                        // that fires the completion INLINE with zero continuity backing. When the worker
+                        // is merely mid-turn (a sub-3s dip between two tool calls), this synchronously
+                        // emitted a false agent:generating_completed the coordinator can never correct.
+                        //
+                        // Route it through the SAME settle + continuity machinery as the normal
+                        // completedDebounce branch: arm completedDebouncePending capturing busyEpochAtArm
+                        // and lastOutputAtArm, then scheduleCompletedDebounceFlush(NATIVE_HISTORY_MESH_IDLE_SETTLE_MS)
+                        // so flushCompletedDebounceIfFinalized() re-verifies CONTINUOUS idle before emitting.
+                        // A busy re-entry (busyEpoch bump) or new PTY output within the settle window —
+                        // exactly what happens when the worker resumes its next tool call — CANCELS the
+                        // false completion. Genuine completions (real final assistant) still emit at the
+                        // end of the (short, 4s) settle window; missingEvidence flows through the
+                        // finalization block (missing_final_assistant → CANON-C weak/held) rather than
+                        // being frozen as a genuine inline fire.
+                        this.completedDebouncePending = {
+                            chatTitle,
+                            duration: Math.round(shortDurationMs / 1000),
+                            timestamp: now,
+                            firstObservedAt: now,
+                            // Short-gen enters from generating→idle (or waiting_approval→idle); the
+                            // completedDebounce finalization gate treats previousStatus for its
+                            // approval-resolution / inter-approval-valley handling. lastStatus is the
+                            // status we transitioned FROM here.
+                            previousStatus: this.lastStatus,
+                            ...(shortTaskId ? { taskId: shortTaskId } : {}),
+                            ...(shortTurnStartedAt ? { turnStartedAt: shortTurnStartedAt } : {}),
+                            // FALSE-IDLE continuity: same arm-time snapshots as the normal branch so the
+                            // flush guard can prove continuous idle across the settle window.
+                            busyEpochAtArm: this.busyEpoch,
+                            ...(typeof adapterStatus?.lastOutputAt === 'number' && Number.isFinite(adapterStatus.lastOutputAt)
+                                ? { lastOutputAtArm: adapterStatus.lastOutputAt as number }
+                                : {}),
+                        };
+                        LOG.info('CLI', `[${this.type}] short-generating routed through settle window (${shortDurationMs}ms, source=${shortEvidenceSource}, missingEvidence=${missingEvidence}) — arming completedDebouncePending instead of inline fire`);
+                        // EVTTRACE: now traces the settle ARM (not an inline fire) for mesh sessions,
+                        // so logs show the short-gen path deferring to continuity re-check.
                         if (this.isMeshWorkerSession()) {
-                            traceMeshEventStage('fired', this.meshTraceCtx(), `short-generating idle (source=${shortEvidenceSource})`);
+                            traceMeshEventStage('arm', this.meshTraceCtx(), `short-generating settle-arm (source=${shortEvidenceSource}, missingEvidence=${missingEvidence})`);
                         }
+                        this.scheduleCompletedDebounceFlush(NATIVE_HISTORY_MESH_IDLE_SETTLE_MS);
+                    } else if (missingEvidence) {
+                        // NON-MESH, missing evidence: suppress the completion event entirely (the
+                        // original !hasMeshContext suppression). A genuinely non-mesh session has no
+                        // coordinator to notify, and firing a completion with no confirmed final
+                        // assistant would just surface an empty/unconfirmed turn. Leave
+                        // completedDebouncePending null — the session is now idle with no confirmed
+                        // turn, matching the startup-blip suppression semantics. (No EvtTrace: not a
+                        // mesh session, so nothing routes to a coordinator.)
+                        LOG.info('CLI', `[${this.type}] short completion suppressed: missing final assistant evidence, non-mesh session (source=${shortEvidenceSource})`);
+                    } else {
+                        // NON-MESH interactive fast-path with a CONFIRMED summary: keep the existing
+                        // inline fire. The dashboard UX reason for the short path (a fast turn should
+                        // surface its completion promptly without a 4s settle) still holds, and a
+                        // non-mesh session has no coordinator to be falsely notified — the false-idle
+                        // bug being fixed is specifically the mesh worker/coordinator misfire above.
                         this.pushEvent({
                             event: 'agent:generating_completed',
                             chatTitle,
@@ -2596,7 +2659,6 @@ export class CliProviderInstance implements ProviderInstance {
                                 reason: 'short_generating_suppressed',
                                 shortDurationMs,
                                 finalAssistantEvidenceSource: shortEvidenceSource,
-                                ...(missingEvidence ? { blockReason: 'missing_final_assistant' } : {}),
                             },
                         });
                     }

package/src/providers/native-history/antigravity-cli-transcript.ts

@@ -556,54 +556,112 @@ interface AgyDbStepRow {
  * Parse a per-session conversations/<uuid>.db (SQLite) into NativeHistoryMessages.
  * Returns null when the db is unreadable, empty, or yields no chat messages.
  */
+/**
+ * True when an error thrown by better-sqlite3 open/read is a transient
+ * SQLITE_BUSY / "database is locked" condition rather than a permanent one.
+ *
+ * On win32 antigravity holds a mandatory WAL write/checkpoint lock while it
+ * persists a step; a readonly open racing that lock throws SQLITE_BUSY. That
+ * is transient — the answer IS already on disk — so it must be retried, NOT
+ * collapsed to "no session" (which erases the just-written assistant answer on
+ * a chat_history re-query). macOS advisory locking + WAL reader-doesn't-block-
+ * writer masks this, which is why it is win32-specific.
+ */
+function isSqliteBusyError(err: unknown): boolean {
+  if (!err) return false;
+  const code = (err as any).code;
+  if (typeof code === 'string' && code.includes('SQLITE_BUSY')) return true;
+  const msg = err instanceof Error ? err.message : String(err);
+  return /SQLITE_BUSY|database is locked|database table is locked/i.test(msg);
+}
+
+const AGY_DB_BUSY_TIMEOUT_MS = 3000;
+const AGY_DB_MAX_ATTEMPTS = 4;
+const AGY_DB_RETRY_BACKOFF_MS = [50, 100, 150];
+
+function sleepBusy(ms: number): void {
+  // Synchronous busy-wait: parseConversationDb is a sync function called from a
+  // sync read path, and better-sqlite3 itself is synchronous. The waits are
+  // tiny (≤150ms) and only occur under genuine lock contention, so a short
+  // spin-sleep is acceptable and keeps the call site synchronous.
+  const end = Date.now() + ms;
+  while (Date.now() < end) { /* spin */ }
+}
+
 function parseConversationDb(
   filePath: string,
   sessionId: string,
   workspace?: string,
 ): NativeHistoryMessage[] | null {
-  let db: any;
+  let Database: any;
   try {
-    const Database = loadBetterSqlite3();
-    db = new Database(filePath, { readonly: true, fileMustExist: true });
+    Database = loadBetterSqlite3();
   } catch (err) {
-    // better-sqlite3 unavailable (ABI mismatch / not installed in this bundle)
-    // or the db handle failed to open. This is the silent-degrade that made a
-    // live read_chat return 0 assistant messages with no trace — the answers
-    // are on disk but unreadable. Log it (once-ish, at WARN) so the failure is
-    // greppable in daemon logs and distinguishable from "no db file". The
-    // reader still degrades gracefully (returns null → dispatcher falls back to
-    // brain/.pb), but the operator now knows WHY the .db path produced nothing.
+    // better-sqlite3 binding genuinely unavailable (ABI mismatch / not built
+    // into this bundle). This is the only true "cannot read at all" case — a
+    // real load failure, distinct from transient lock contention below. Warn
+    // once at WARN so it is greppable; the reader degrades gracefully (returns
+    // null → dispatcher falls back to brain/.pb).
     LOG.warn(
       'NativeHistory',
-      `antigravity .db reader could not open ${path.basename(filePath)}: ${err instanceof Error ? err.message : String(err)} (better-sqlite3 load/open failed — assistant answers in this .db will not surface)`,
+      `antigravity .db reader could not load better-sqlite3 for ${path.basename(filePath)}: ${err instanceof Error ? err.message : String(err)} (native binding unavailable — assistant answers in this .db will not surface)`,
     );
     return null;
   }
 
-  let rows: AgyDbStepRow[];
-  try {
-    rows = db
-      .prepare(
-        `SELECT idx, step_type, step_payload
-           FROM steps
-          WHERE step_type IN (${AGY_STEP_TYPE_USER}, ${AGY_STEP_TYPE_MODEL})
-          ORDER BY idx ASC`,
-      )
-      .all() as AgyDbStepRow[];
-  } catch (err) {
-    // `steps` table absent / unexpected schema — a real (but recoverable)
-    // shape mismatch, not the binding-missing case above. Log at debug so a
-    // schema drift in a future antigravity release is diagnosable without
-    // spamming logs for every legacy db.
-    LOG.debug(
-      'NativeHistory',
-      `antigravity .db ${path.basename(filePath)} has no readable steps table: ${err instanceof Error ? err.message : String(err)}`,
-    );
-    return null;
-  } finally {
-    try { db.close(); } catch { /* ignore */ }
+  let rows: AgyDbStepRow[] | null = null;
+  let lastBusyErr: unknown;
+
+  for (let attempt = 1; attempt <= AGY_DB_MAX_ATTEMPTS; attempt++) {
+    let db: any;
+    try {
+      db = new Database(filePath, { readonly: true, fileMustExist: true });
+      // Ask SQLite itself to wait (rather than failing fast) if the WAL
+      // lock is momentarily held by antigravity. Set as early as possible
+      // after open so the prepare/all below inherits the wait.
+      try { db.pragma(`busy_timeout = ${AGY_DB_BUSY_TIMEOUT_MS}`); } catch { /* ignore */ }
+      rows = db
+        .prepare(
+          `SELECT idx, step_type, step_payload
+             FROM steps
+            WHERE step_type IN (${AGY_STEP_TYPE_USER}, ${AGY_STEP_TYPE_MODEL})
+            ORDER BY idx ASC`,
+        )
+        .all() as AgyDbStepRow[];
+      break; // success
+    } catch (err) {
+      if (isSqliteBusyError(err)) {
+        // Transient WAL lock contention. Do NOT collapse to null on the first
+        // failure — the assistant answer is already persisted; treating a busy
+        // lock as "no session" is exactly what erased answers on re-query.
+        // Retry with a small backoff; only give up after attempts exhausted.
+        lastBusyErr = err;
+        if (attempt < AGY_DB_MAX_ATTEMPTS) {
+          sleepBusy(AGY_DB_RETRY_BACKOFF_MS[attempt - 1] ?? 150);
+          continue;
+        }
+        LOG.warn(
+          'NativeHistory',
+          `antigravity .db ${path.basename(filePath)} stayed locked (SQLITE_BUSY) after ${AGY_DB_MAX_ATTEMPTS} attempts: ${err instanceof Error ? err.message : String(err)} (WAL write/checkpoint lock contention — assistant answers may transiently not surface this read)`,
+        );
+        return null;
+      }
+      // `steps` table absent / unexpected schema, or a genuine open/parse
+      // failure that is not lock contention — a real (but recoverable) shape
+      // mismatch. Log at debug so a schema drift in a future antigravity
+      // release is diagnosable without spamming logs for every legacy db.
+      LOG.debug(
+        'NativeHistory',
+        `antigravity .db ${path.basename(filePath)} not readable: ${err instanceof Error ? err.message : String(err)}`,
+      );
+      return null;
+    } finally {
+      try { db?.close(); } catch { /* ignore */ }
+    }
   }
 
+  void lastBusyErr; // referenced only for retry bookkeeping above
+
   if (!Array.isArray(rows) || rows.length === 0) return null;
 
   const normalizedWorkspace = typeof workspace === 'string' ? workspace.trim() : '';