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

package/dist/mesh/mesh-node-identity.d.ts

@@ -48,6 +48,7 @@ export declare function buildLivePeerGitConnection(connection: Record<string, un
 export declare function recordInlineMeshDirectGitTruth(node: any, git: Record<string, unknown>, source: 'selected_coordinator_local_git' | 'selected_coordinator_mesh_p2p_git'): {
     reporterPlatform: string | null;
     reporterArch: string | null;
+    reporterMachineNickname: string | null;
 };
 /**
  * Persist the live self-reported platform/arch onto the local meshes.json node
@@ -63,6 +64,7 @@ export declare function recordInlineMeshDirectGitTruth(node: any, git: Record<st
 export declare function persistNodeReporterPlatform(meshSource: 'inline_cache' | 'inline_bootstrap' | 'local_config', mesh: any, nodeId: string | undefined, reporter: {
     reporterPlatform: string | null;
     reporterArch: string | null;
+    reporterMachineNickname?: string | null;
 }): void;
 export declare function inlineMeshCarriesTransientNodeTruth(inlineMesh: any): boolean;
 export declare function readInlineMeshNodeId(node: any): string;

package/dist/repo-mesh-types.d.ts

@@ -580,6 +580,16 @@ export interface LocalMeshNodeEntry {
      */
     reportedPlatform?: string;
     reportedArch?: string;
+    /**
+     * The operator-set machine nickname (config.machineNickname) of the daemon
+     * that owns this node's workspace. The local coordinator stamps its own
+     * config value onto its self/base node; a remote member self-reports its
+     * value on the git_status envelope (reporterMachineNickname), which the
+     * coordinator persists here on each direct git probe. Feeds
+     * buildMeshNodeDisplayLabel so the mesh UI renders the friendly nickname
+     * instead of a raw daemonId/nodeId. Absent until set/first-reported.
+     */
+    machineNickname?: string;
     policy: RepoMeshNodePolicy;
     /**
      * Per-node instruction surfaced in the coordinator prompt so the LLM

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.445",
+  "version": "0.9.82-rc.447",
   "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.447",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/high-family/mesh-status.ts

@@ -180,6 +180,13 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                     const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
 
                     const localMachineId = loadConfig().machineId || '';
+                    // Local daemon's operator-set nickname — stamped onto the self/base
+                    // node at render time so the friendly label resolves even before the
+                    // persisted node record (addNode) has been rewritten with it.
+                    const localMachineNickname = (() => {
+                        const nick = loadConfig().machineNickname;
+                        return typeof nick === 'string' && nick.trim() ? nick.trim() : '';
+                    })();
                     const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
                     // Shared probe gate for this mesh_status call: the bootstrap
                     // hydrate below and the per-node render loop further down both
@@ -302,6 +309,14 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                             daemonId && (daemonIdsEquivalent(daemonId, localMachineId) || daemonIdsEquivalent(daemonId, ctx.deps.statusInstanceId)),
                         ) || Boolean(meshRecord?.inline && nodeIndex === 0)
                             || sparseConfiguredCoordinatorNode;
+                        // The self/base node's friendly label comes from THIS daemon's
+                        // local config.machineNickname. Stamp it onto the node record (if
+                        // not already carried) so buildMeshNodeDisplayLabel below resolves
+                        // to the nickname and labelSource reads 'explicit_metadata' even
+                        // before addNode's persisted record has been rewritten.
+                        if (isSelfNode && localMachineNickname && !readStringValue(node.machineNickname, node.machine_nickname)) {
+                            node.machineNickname = localMachineNickname;
+                        }
                         const machineIdentity = buildMeshNodeMachineIdentity(node as Record<string, unknown>, {
                             localMachineId,
                             localDaemonId: ctx.deps.statusInstanceId,

package/src/config/mesh-config.ts

@@ -10,7 +10,7 @@ import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { randomBytes, randomUUID } from 'crypto';
 import { shortHash } from '../system/hash.js';
-import { getConfigDir } from './config.js';
+import { getConfigDir, loadConfig } from './config.js';
 import type {
     LocalMeshConfig,
     LocalMeshEntry,
@@ -492,6 +492,11 @@ export interface AddNodeOptions {
     clonedFromNodeId?: string;
     worktreeBootstrap?: LocalMeshNodeEntry['worktreeBootstrap'];
     role?: RepoMeshDaemonRole;
+    /** Owning daemon's machine nickname. Defaults to this daemon's local
+     *  config.machineNickname when omitted — a node is always added by (and on)
+     *  the daemon that owns its workspace (self/base node or a local worktree
+     *  clone), so the local config is the correct source. */
+    machineNickname?: string;
 }
 
 export function addNode(meshId: string, opts: AddNodeOptions): LocalMeshNodeEntry | undefined {
@@ -508,12 +513,27 @@ export function addNode(meshId: string, opts: AddNodeOptions): LocalMeshNodeEntr
         throw new Error('This workspace is already in the mesh');
     }
 
+    // A node is always added by the daemon that owns its workspace (the self/base
+    // node, or a local worktree clone spawned from this daemon), so this daemon's
+    // config.machineNickname is the correct owner nickname. Explicit opt wins.
+    const machineNickname = (() => {
+        const explicit = typeof opts.machineNickname === 'string' ? opts.machineNickname.trim() : '';
+        if (explicit) return explicit;
+        try {
+            const local = loadConfig().machineNickname;
+            return typeof local === 'string' && local.trim() ? local.trim() : undefined;
+        } catch {
+            return undefined;
+        }
+    })();
+
     const node: LocalMeshNodeEntry = {
         id: `node_${randomUUID().replace(/-/g, '')}`,
         workspace: opts.workspace.trim(),
         repoRoot: opts.repoRoot,
         daemonId: opts.daemonId,
         machineId: opts.machineId,
+        ...(machineNickname ? { machineNickname } : {}),
         capabilities: normalizeCapabilityTags(opts.capabilities),
         userOverrides: opts.userOverrides || {},
         policy: opts.policy || {},
@@ -559,6 +579,10 @@ export function updateNode(
          *  operator intent) so capability-tag os=/arch= self-heals across loads. */
         reportedPlatform?: string;
         reportedArch?: string;
+        /** Owning daemon's self-reported machine nickname, carried on the
+         *  git_status envelope. Persisted so the friendly label survives across
+         *  coordinator restarts (mirrors reportedPlatform/reportedArch). */
+        reportedMachineNickname?: string;
     },
 ): LocalMeshNodeEntry | undefined {
     const config = loadMeshConfig();
@@ -571,6 +595,7 @@ export function updateNode(
     if (opts.userOverrides) node.userOverrides = { ...node.userOverrides, ...opts.userOverrides };
     if (opts.reportedPlatform && opts.reportedPlatform.trim()) node.reportedPlatform = opts.reportedPlatform.trim();
     if (opts.reportedArch && opts.reportedArch.trim()) node.reportedArch = opts.reportedArch.trim();
+    if (opts.reportedMachineNickname && opts.reportedMachineNickname.trim()) node.machineNickname = opts.reportedMachineNickname.trim();
     if (opts.policy) node.policy = { ...node.policy, ...opts.policy };
     if (opts.worktreeBootstrap) node.worktreeBootstrap = opts.worktreeBootstrap;
     if (Object.prototype.hasOwnProperty.call(opts, 'systemPrompt')) {

package/src/git/git-commands.ts

@@ -4,6 +4,7 @@ import { getGitDiffSummary, getGitFileDiff } from './git-diff.js';
 import { GitCommandError, isPathInside, resolveGitRepository, runGit } from './git-executor.js';
 import { createGitSnapshotStore } from './git-snapshot-store.js';
 import { getGitRepoStatus } from './git-status.js';
+import { loadConfig } from '../config/config.js';
 import type {
   GitCommandName,
   GitDiffSummary,
@@ -113,7 +114,9 @@ type GitCommandSuccess =
   // reporterPlatform/reporterArch carry the responding daemon's process.platform/
   // process.arch so a mesh coordinator probing this node over P2P can self-heal the
   // node's userOverrides.platform/arch (the fields capability-tag routing reads).
-  | { success: true; status: GitRepoStatus; reporterPlatform?: string; reporterArch?: string }
+  // reporterMachineNickname carries the responding daemon's config.machineNickname
+  // so the coordinator can populate node.machineNickname → the friendly display label.
+  | { success: true; status: GitRepoStatus; reporterPlatform?: string; reporterArch?: string; reporterMachineNickname?: string }
   | { success: true; diffSummary: GitDiffSummary }
   | { success: true; diff: GitFileDiff }
   | { success: true; snapshot: GitSnapshot }
@@ -315,7 +318,23 @@ export async function handleGitCommand(
       // stamps it onto the node's userOverrides.platform/arch (the fields
       // buildMeshNodeCapabilityTags reads). These are siblings of `status`, not
       // part of GitRepoStatus, so the git payload shape is untouched.
-      return { success: true, status, reporterPlatform: process.platform, reporterArch: process.arch };
+      // The machine nickname rides the same channel so the coordinator can render
+      // this node's friendly label instead of a raw daemonId/nodeId.
+      const reporterMachineNickname = (() => {
+        try {
+          const nick = loadConfig().machineNickname;
+          return typeof nick === 'string' && nick.trim() ? nick.trim() : undefined;
+        } catch {
+          return undefined;
+        }
+      })();
+      return {
+        success: true,
+        status,
+        reporterPlatform: process.platform,
+        reporterArch: process.arch,
+        ...(reporterMachineNickname ? { reporterMachineNickname } : {}),
+      };
     }
 
     case 'git_diff_summary': {

package/src/mesh/mesh-node-identity.ts

@@ -319,9 +319,9 @@ export function recordInlineMeshDirectGitTruth(
     node: any,
     git: Record<string, unknown>,
     source: 'selected_coordinator_local_git' | 'selected_coordinator_mesh_p2p_git',
-): { reporterPlatform: string | null; reporterArch: string | null } {
+): { reporterPlatform: string | null; reporterArch: string | null; reporterMachineNickname: string | null } {
     if (!node || typeof node !== 'object' || Array.isArray(node)) {
-        return { reporterPlatform: null, reporterArch: null };
+        return { reporterPlatform: null, reporterArch: null, reporterMachineNickname: null };
     }
     const checkedAt = readNumberValue(git.lastCheckedAt) ?? Date.now();
     const updatedAt = new Date(checkedAt).toISOString();
@@ -359,7 +359,14 @@ export function recordInlineMeshDirectGitTruth(
     // for an inline/cache mesh this keeps the runtime object self-consistent.
     if (reporterPlatform) node.reportedPlatform = reporterPlatform;
     if (reporterArch) node.reportedArch = reporterArch;
-    return { reporterPlatform, reporterArch };
+    // Machine nickname: only a remote member self-reports it (reporterMachineNickname
+    // rides the git_status envelope). For a local_source probe the workspace lives on
+    // THIS machine, but the self/base node already carries the local config nickname
+    // (addNode stamps it), so we only stamp from an explicit report here — never
+    // overwrite an existing nickname with an empty value.
+    const reporterMachineNickname = readStringValue(git.reporterMachineNickname) ?? null;
+    if (reporterMachineNickname) node.machineNickname = reporterMachineNickname;
+    return { reporterPlatform, reporterArch, reporterMachineNickname };
 }
 
 /**
@@ -396,16 +403,17 @@ export function persistNodeReporterPlatform(
     meshSource: 'inline_cache' | 'inline_bootstrap' | 'local_config',
     mesh: any,
     nodeId: string | undefined,
-    reporter: { reporterPlatform: string | null; reporterArch: string | null },
+    reporter: { reporterPlatform: string | null; reporterArch: string | null; reporterMachineNickname?: string | null },
 ): void {
     if (meshSource !== 'local_config') return;
     const meshId = readStringValue(mesh?.id);
     if (!meshId || !nodeId) return;
     const reportedPlatform = reporter.reporterPlatform ?? undefined;
     const reportedArch = reporter.reporterArch ?? undefined;
-    if (!reportedPlatform && !reportedArch) return;
+    const reportedMachineNickname = reporter.reporterMachineNickname ?? undefined;
+    if (!reportedPlatform && !reportedArch && !reportedMachineNickname) return;
     void import('../config/mesh-config.js')
-        .then(({ updateNode }) => updateNode(meshId, nodeId, { reportedPlatform, reportedArch }))
+        .then(({ updateNode }) => updateNode(meshId, nodeId, { reportedPlatform, reportedArch, reportedMachineNickname }))
         .catch(() => { /* best-effort self-heal; never block status assembly */ });
 }
 
@@ -1409,9 +1417,11 @@ async function probeRemoteMeshGitStatus(args: {
     // persist them to node.userOverrides without touching the git status shape.
     const reporterPlatform = readStringValue(remoteResult?.reporterPlatform);
     const reporterArch = readStringValue(remoteResult?.reporterArch);
+    const reporterMachineNickname = readStringValue(remoteResult?.reporterMachineNickname);
     const git = remoteGit as Record<string, unknown>;
     if (reporterPlatform) git.reporterPlatform = reporterPlatform;
     if (reporterArch) git.reporterArch = reporterArch;
+    if (reporterMachineNickname) git.reporterMachineNickname = reporterMachineNickname;
     return git;
 }
 

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() : '';

package/src/repo-mesh-types.ts

@@ -849,6 +849,16 @@ export interface LocalMeshNodeEntry {
      */
     reportedPlatform?: string;
     reportedArch?: string;
+    /**
+     * The operator-set machine nickname (config.machineNickname) of the daemon
+     * that owns this node's workspace. The local coordinator stamps its own
+     * config value onto its self/base node; a remote member self-reports its
+     * value on the git_status envelope (reporterMachineNickname), which the
+     * coordinator persists here on each direct git probe. Feeds
+     * buildMeshNodeDisplayLabel so the mesh UI renders the friendly nickname
+     * instead of a raw daemonId/nodeId. Absent until set/first-reported.
+     */
+    machineNickname?: string;
     policy: RepoMeshNodePolicy;
     /**
      * Per-node instruction surfaced in the coordinator prompt so the LLM