@adhdev/daemon-core 0.9.82-rc.457 → 0.9.82-rc.459

package/src/providers/chat-message-normalization.ts

@@ -104,22 +104,56 @@ export function extractFinalAssistantSummaryEvidence(
   messages: ChatMessage[] | null | undefined,
   maxChars: number = DEFAULT_FINAL_SUMMARY_MAX_CHARS,
 ): { finalSummary: string; transcriptMessageAt?: string } {
-  if (!Array.isArray(messages) || messages.length === 0) return { finalSummary: '' };
+  const turnEnd = selectFinalAssistantTurnEndMessage(messages);
+  if (!turnEnd) return { finalSummary: '' };
+  return {
+    finalSummary: flattenContent(turnEnd.content).trim().slice(0, maxChars),
+    transcriptMessageAt: readChatMessageTimestampIso(turnEnd),
+  };
+}
+
+/**
+ * EARLYNOTIFY-GATEBYPASS (a)/(b) — the shared turn-finality selector for the completion
+ * final-assistant judgement, so the ~duplicated "which bubble is the turn's final answer"
+ * logic is decided ONE way (UNIFY A-6).
+ *
+ * Returns the message that qualifies as the turn's FINAL assistant bubble, or null when the
+ * transcript does not (yet) prove a turn end. The rule is a NON-EMPTY LATEST user-facing
+ * assistant/model bubble:
+ *   - Scanning from the end, the FIRST user-facing assistant/model bubble encountered IS the
+ *     turn-end candidate. If it is EMPTY (a streaming placeholder / mid-turn narration whose
+ *     text has not landed), the turn is still in flight → return null. Crucially we do NOT walk
+ *     back past that empty bubble to promote an EARLIER assistant narration to "final" (the
+ *     Defect-B walk-back).
+ *   - Trailing activity/internal bubbles (tool/thought/status) are skipped — they are not the
+ *     assistant's user-facing answer.
+ *   - A trailing user-facing USER message (a freshly dispatched task with no reply yet) means the
+ *     assistant did not have the last word — no earlier bubble is promoted here; callers that must
+ *     still reach a prior turn's tail use the timestamp-scoped extractor instead.
+ *
+ * A bare snapshot-idle with an arbitrary non-empty tail therefore does NOT qualify as a turn end;
+ * only a genuine latest-assistant bubble does. Turn-finality signals that live OUTSIDE the
+ * transcript (a committed generating→idle FSM transition, a self-attributing final_summary_json,
+ * or a continuous-idle streak) are enforced by the callers (the CLI completion gate, the reconcile
+ * grace gate) on top of this structural check.
+ */
+export function selectFinalAssistantTurnEndMessage(
+  messages: ChatMessage[] | null | undefined,
+): ChatMessage | null {
+  if (!Array.isArray(messages) || messages.length === 0) return null;
   for (let i = messages.length - 1; i >= 0; i--) {
     const msg = messages[i];
     if (!msg) continue;
     const classification = classifyChatMessageVisibility(msg);
-    if (classification.isUserFacing && (msg.role === 'assistant' || msg.role === 'model')) {
-      const text = flattenContent(msg.content).trim();
-      if (text) {
-        return {
-          finalSummary: text.slice(0, maxChars),
-          transcriptMessageAt: readChatMessageTimestampIso(msg),
-        };
-      }
+    if (!classification.isUserFacing) continue; // skip tool/thought/status activity + internal
+    if (msg.role === 'assistant' || msg.role === 'model') {
+      // The latest user-facing assistant bubble: it is the turn end iff it has real text.
+      return flattenContent(msg.content).trim() ? msg : null;
     }
+    // A user (or other role) had the last user-facing word → the assistant turn is not complete.
+    return null;
   }
-  return { finalSummary: '' };
+  return null;
 }
 
 export const BUILTIN_CHAT_MESSAGE_KINDS = ['standard', 'thought', 'tool', 'terminal', 'system'] as const;

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

@@ -31,6 +31,11 @@ import { formatAutoApprovalMessage, pickApprovalButton, hasNegativeApprovalOptio
 import { getCliScriptCommand, parseCliScriptResult } from './cli-script-results.js';
 import { mergeProviderPatchState, resolveProviderStateSurface } from './provider-patch-state.js';
 import { normalizeProviderSessionId } from './provider-session-id.js';
+import {
+    antigravityOwnerToken,
+    claimAntigravityConversation,
+    releaseAntigravityOwner,
+} from './native-history/antigravity-claim-registry.js';
 import { buildChatMessage, buildRuntimeSystemChatMessage, isUserFacingChatMessage, normalizeChatMessages, resolveChatMessageKind, extractFinalSummaryFromMessages, extractFinalSummaryFromMessagesAfter, readChatMessageTimestampMs } from './chat-message-normalization.js';
 import { workingDirBasename } from './working-dir.js';
 import { ManualAttendanceTracker } from './manual-attendance.js';
@@ -1394,7 +1399,24 @@ export class CliProviderInstance implements ProviderInstance {
         }
     }
 
+    /**
+     * Owner token for this session in the antigravity conversation-claim
+     * registry. Derived identically to the dispatcher's read-side token
+     * (workspace + spawn time) so the claims the dispatcher records under this
+     * session are the ones dispose() releases.
+     */
+    private antigravityClaimOwner(): string {
+        return antigravityOwnerToken(this.workingDir, this.startedAt);
+    }
+
     dispose(): void {
+        // Release this session's antigravity conversation claims so the store
+        // becomes available again (e.g. a later resume) and the registry doesn't
+        // leak entries for dead sessions.
+        if (this.type === 'antigravity-cli') {
+            const owner = this.antigravityClaimOwner();
+            if (owner) releaseAntigravityOwner(owner);
+        }
         this.adapter.shutdown();
         this.monitor.reset();
         // Cancel any armed auto-approve timers so a pending settle re-check
@@ -2483,12 +2505,27 @@ export class CliProviderInstance implements ProviderInstance {
         if (this.isMeshWorkerSession()) {
             traceMeshEventStage('fired', this.meshTraceCtx(), `${reason} (source=${fcEvidenceSource})`);
         }
+        // EARLYNOTIFY-GATEBYPASS (c): a startup-grace fast-collapse never OBSERVED the turn's
+        // generating phase — its evidence is a plain transcript tail, never a self-attributing
+        // final_summary_json — so this synth is TENTATIVE by default. Mark it WEAK
+        // (evidenceLevel:'weak') so buildPendingEventFingerprint keys it `…::weak` and any later
+        // genuine agent:generating_completed for the same task can still surface (CANON-B). The
+        // stronger missing_final_assistant marker is preserved when there is also no summary.
+        if (this.completionTraceOn()) this.recordCompletionGateTrace('synth-fire', {
+            path: 'startup_grace_fast_collapse',
+            reason,
+            evidenceSource: fcEvidenceSource,
+            hadFinalSummary: !!fcFinalSummary,
+            missingEvidence,
+            evidenceLevel: 'weak',
+        });
         this.pushEvent({
             event: 'agent:generating_completed',
             chatTitle,
             duration: 0,
             timestamp: now,
             finalSummary: fcFinalSummary,
+            evidenceLevel: 'weak',
             completionDiagnostic: {
                 reason,
                 finalAssistantEvidenceSource: fcEvidenceSource,
@@ -3604,6 +3641,15 @@ export class CliProviderInstance implements ProviderInstance {
         const previousHistorySessionId = this.providerSessionId || this.instanceId;
         const previousProviderSessionId = this.providerSessionId;
         this.providerSessionId = nextSessionId;
+        // Conversation-binding lock (antigravity): the moment this session is
+        // authoritatively bound to a conversation uuid, claim it so a concurrent
+        // sibling session's newest-on-disk discovery can never resolve to the
+        // same .db (RCA: two antigravity sessions ~94ms apart shared one store
+        // and cross-routed completions). Released on dispose().
+        if (this.type === 'antigravity-cli') {
+            const owner = this.antigravityClaimOwner();
+            if (owner) claimAntigravityConversation(nextSessionId, owner);
+        }
         this.historyWriter.promoteHistorySession(this.type, previousHistorySessionId, nextSessionId);
         this.historyWriter.writeSessionStart(this.type, nextSessionId, this.workingDir, this.instanceId);
         if (this.shouldHydrateExistingProviderHistory()) {

package/src/providers/native-history/antigravity-claim-registry.ts

@@ -0,0 +1,131 @@
+/**
+ * antigravity-claim-registry — daemon-local conversation ownership map.
+ *
+ * Antigravity CLI writes each conversation into its own per-session SQLite db
+ * at ~/.gemini/antigravity-cli/conversations/<uuid>.db. But before a daemon
+ * session has resolved its provider session id, the discovery resolver used to
+ * fall back to "the newest .db on disk by mtime". Two sessions started within a
+ * few ms of each other on ONE daemon therefore both grabbed the SAME newest
+ * store — so one session's injected prompt and the other's assistant completion
+ * cross-routed, and an unrelated turn completed the wrong task (RCA: a
+ * coordinator session ended up reading the owner's conversation .db, and the
+ * coordinator's own injected instruction was absent from the bound store).
+ *
+ * This registry records which live daemon session currently owns a given
+ * conversation uuid. The discovery resolver (dispatcher.resolveAntigravityPath)
+ * consults it to:
+ *   (1) never hand a conversation already owned by a DIFFERENT live session to
+ *       an as-yet-unbound one — two sessions can never resolve to the same .db;
+ *   (2) LOCK a session to the first conversation it binds, so a later, newer
+ *       .db on disk cannot re-bind an already-bound session on a subsequent
+ *       mtime-ordered read.
+ *
+ * Ownership is keyed by a per-session owner token (see antigravityOwnerToken)
+ * that BOTH the resolver and the provider instance derive identically from the
+ * same inputs (workspace + spawn time, or the instance id), so the instance can
+ * release its claims deterministically on shutdown.
+ *
+ * A claim not refreshed within CLAIM_STALE_MS is treated as abandoned — a
+ * safety net for a session that died without an explicit release. Live sessions
+ * poll native history far more frequently than this window, so an active owner
+ * never lapses; only a crashed/leaked owner's claim ages out.
+ *
+ * OSS code (AGPL-3.0). Must not import from packages/ (proprietary).
+ */
+'use strict';
+
+interface ConversationClaim {
+  owner: string;
+  /** Last time this owner (re)confirmed the claim. Only consulted by the
+   *  stale-claim safety net; an active owner refreshes it on every resolve. */
+  refreshedAtMs: number;
+}
+
+const claimsByUuid = new Map<string, ConversationClaim>();
+
+/** A claim older than this with no refresh is reclaimable (owner presumed dead). */
+export const CLAIM_STALE_MS = 10 * 60 * 1000;
+
+function normalizeUuid(uuid: string): string {
+  return String(uuid || '').trim().toLowerCase();
+}
+
+/**
+ * Derive the per-session owner token. Both the dispatcher (from the read input:
+ * workspace + sessionStartedAtMs) and the provider instance (from its
+ * workingDir + startedAt, or its instanceId) call this with the same inputs so
+ * claims and releases line up. Returns '' when there is no stable identity to
+ * key on (e.g. a workspace-less discovery with no spawn time) — the caller then
+ * skips claiming but the exclusion checks still run against existing claims.
+ */
+export function antigravityOwnerToken(
+  workspace: string,
+  sessionStartedAtMs: number,
+  instanceId?: string,
+): string {
+  const iid = typeof instanceId === 'string' ? instanceId.trim() : '';
+  if (iid) return `iid:${iid}`;
+  if (typeof sessionStartedAtMs === 'number' && sessionStartedAtMs > 0) {
+    const ws = String(workspace || '').trim().toLowerCase();
+    return `spawn:${ws}:${sessionStartedAtMs}`;
+  }
+  return '';
+}
+
+/**
+ * Claim `uuid` for `owner`. Succeeds (and refreshes) when the conversation is
+ * unclaimed, already owned by this owner, or held by a stale (abandoned) owner.
+ * Fails when a DIFFERENT live owner holds it. Returns whether `owner` holds the
+ * claim after the call.
+ */
+export function claimAntigravityConversation(uuid: string, owner: string, now: number = Date.now()): boolean {
+  const key = normalizeUuid(uuid);
+  if (!key || !owner) return false;
+  const existing = claimsByUuid.get(key);
+  if (existing && existing.owner !== owner && (now - existing.refreshedAtMs) < CLAIM_STALE_MS) {
+    return false;
+  }
+  claimsByUuid.set(key, { owner, refreshedAtMs: now });
+  return true;
+}
+
+/** True when `uuid` is held by a live owner OTHER than `owner`. */
+export function isAntigravityConversationClaimedByOther(uuid: string, owner: string, now: number = Date.now()): boolean {
+  const key = normalizeUuid(uuid);
+  if (!key) return false;
+  const existing = claimsByUuid.get(key);
+  if (!existing) return false;
+  if (existing.owner === owner) return false;
+  return (now - existing.refreshedAtMs) < CLAIM_STALE_MS;
+}
+
+/** The live owner of `uuid`, or undefined when unclaimed or stale. */
+export function antigravityConversationOwner(uuid: string, now: number = Date.now()): string | undefined {
+  const key = normalizeUuid(uuid);
+  if (!key) return undefined;
+  const existing = claimsByUuid.get(key);
+  if (!existing) return undefined;
+  if ((now - existing.refreshedAtMs) >= CLAIM_STALE_MS) return undefined;
+  return existing.owner;
+}
+
+/** Release a single conversation, only if held by `owner` (or `owner` empty). */
+export function releaseAntigravityConversation(uuid: string, owner?: string): void {
+  const key = normalizeUuid(uuid);
+  if (!key) return;
+  const existing = claimsByUuid.get(key);
+  if (existing && (!owner || existing.owner === owner)) claimsByUuid.delete(key);
+}
+
+/** Release every conversation held by `owner` (called on session shutdown). */
+export function releaseAntigravityOwner(owner: string): void {
+  if (!owner) return;
+  for (const [key, claim] of claimsByUuid) {
+    if (claim.owner === owner) claimsByUuid.delete(key);
+  }
+}
+
+/** Test-only: wipe all claims so each test starts from a clean registry. */
+export function __resetAntigravityClaimRegistry(): void {
+  claimsByUuid.clear();
+}

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

@@ -38,6 +38,17 @@
  *      pty parser (which only echoes the user's own input) — assistant
  *      answers appeared lost even though they were on disk.
  *
+ *      Schema-drift resilience: the exact field path (20 → 1/8 for the answer,
+ *      19 → 2/3 for the prompt) is empirically verified against real stores, but
+ *      antigravity may move it in a future build. So when the known path yields
+ *      no text, instead of silently dropping the turn we fall back to a UTF-8
+ *      printable-run scan of the payload (recoverMessageText) that recovers the
+ *      answer/prompt even if the field number drifted — while explicitly
+ *      EXCLUDING the reasoning subtree (20 → 3) so internal reasoning is never
+ *      surfaced as the answer. Only when even that finds nothing beyond
+ *      reasoning/metadata is the step dropped, and a content-free DEBUG
+ *      breadcrumb is logged so a real drift is greppable rather than invisible.
+ *
  * This adapter provides:
  *   - Full coverage from a per-session .db (current format) — preferred.
  *   - Full coverage when a brain transcript exists (legacy authoritative source).
@@ -546,6 +557,100 @@ function extractUserPrompt(payload: Buffer): string {
   return extractUserRequestContent(text);
 }
 
+/**
+ * The model step's private reasoning summary lives at field 20 → field 3. We
+ * surface it nowhere, but we DO need it: the schema-drift recovery below scans
+ * the raw payload for a plausible answer run, and the reasoning is itself a long
+ * natural-language run — so we extract it here purely to EXCLUDE it and avoid
+ * accidentally surfacing internal reasoning as the assistant answer.
+ */
+function extractModelReasoning(payload: Buffer): string {
+  const inner = firstLenField(payload, 20);
+  if (!inner) return '';
+  const reasoning = firstLenField(inner, 3);
+  if (!reasoning || !looksLikeText(reasoning)) return '';
+  return reasoning.toString('utf-8').trim();
+}
+
+/** Top-level protobuf field numbers present in a payload (for drift breadcrumbs). */
+function topLevelFieldNumbers(payload: Buffer): number[] {
+  return decodeProtoFields(payload).map((f) => f.field);
+}
+
+const MIN_RECOVERED_MESSAGE_CHARS = 12;
+
+/**
+ * Split a payload into UTF-8 text runs, schema-agnostically. Unlike
+ * extractStringsFromBuffer (ASCII-only, used for legacy .pb), this is UTF-8 aware
+ * so CJK / accented answers survive intact: we decode the whole blob as UTF-8
+ * (invalid byte sequences collapse to U+FFFD) and split on runs of C0/C1 control
+ * chars + the replacement char. Protobuf framing bytes (field tags, varint length
+ * prefixes) are almost always control or invalid-UTF-8, so each natural-language
+ * string field emerges as its own run while binary framing is discarded.
+ */
+function extractUtf8TextRuns(buf: Buffer): string[] {
+  if (buf.length === 0) return [];
+  const decoded = buf.toString('utf-8');
+  // Keep tab/newline/CR (0x09/0x0A/0x0D) inside runs — answers contain newlines.
+  // Everything else in C0 (incl. 0x1A, the field-3 tag that separates reasoning
+  // from the answer), DEL, and the replacement char are run separators.
+  const parts = decoded.split(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F\uFFFD]+/);
+  const runs: string[] = [];
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (trimmed.length >= MIN_PRINTABLE_RUN) runs.push(trimmed);
+  }
+  return runs;
+}
+
+/**
+ * Is this run plausibly a user-visible prose message, as opposed to the other
+ * text the payload also carries — internal reasoning (excluded separately),
+ * tool-call JSON arguments, code blobs, file paths, and uuid/session-id
+ * metadata? These filters were tuned against real antigravity stores so that a
+ * blind printable-run scan recovers a genuinely drifted answer while surfacing
+ * NONE of the tool-call / metadata runs that legitimately answer-less steps
+ * carry (verified: zero false recoveries across real conversation dbs).
+ */
+function isPlausibleMessageText(s: string): boolean {
+  if (s.length < MIN_RECOVERED_MESSAGE_CHARS) return false;
+  if (!/[A-Za-zÀ-￿]/.test(s)) return false; // must contain letters (incl. CJK)
+  if (/^(file:\/\/|[A-Za-z]:[\\/]|\/[A-Za-z0-9._-]+\/)/.test(s)) return false; // path/URI
+  // Prose is multi-word: real answers have several spaces; uuids / ids / tokens
+  // have none. This is the single strongest prose-vs-metadata discriminator.
+  if ((s.match(/ /g) ?? []).length < 2) return false;
+  // Reject structured tool-call args / JSON / code blobs. A model tool step
+  // carries its arguments as JSON (e.g. {"Query":...}, {"CommandLine":...});
+  // those must never be surfaced as an assistant answer.
+  if (/[[{]\s*"/.test(s)) return false;
+  const structural = (s.match(/[{}[\]":\\]/g) ?? []).length;
+  if (structural / s.length > 0.12) return false;
+  return true;
+}
+
+/**
+ * Schema-agnostic recovery of a message's text when the known field path yields
+ * nothing (a possible antigravity step_payload schema drift). Scans the payload
+ * for UTF-8 text runs and returns the longest plausible message run, EXCLUDING
+ * any run that matches one of `excludeTexts` (e.g. the reasoning subtree) so we
+ * never surface internal reasoning as the answer. Returns '' when nothing beyond
+ * reasoning/metadata is present — i.e. a legitimately answer-less step.
+ */
+function recoverMessageText(payload: Buffer, excludeTexts: string[]): string {
+  const exclusions = excludeTexts.map((t) => t.trim()).filter(Boolean);
+  let best = '';
+  for (const run of extractUtf8TextRuns(payload)) {
+    const candidate = stripAnswerMarker(run).trim();
+    if (!isPlausibleMessageText(candidate)) continue;
+    // Drop runs that are (or are contained in / contain) an excluded subtree.
+    if (exclusions.some((e) => e === candidate || e.includes(candidate) || candidate.includes(e))) {
+      continue;
+    }
+    if (candidate.length > best.length) best = candidate;
+  }
+  return best;
+}
+
 interface AgyDbStepRow {
   idx: number;
   step_type: number;
@@ -678,8 +783,27 @@ function parseConversationDb(
     const receivedAt = baseTs + messages.length;
 
     if (row.step_type === AGY_STEP_TYPE_USER) {
-      const content = extractUserPrompt(payload);
-      if (!content) continue;
+      let content = extractUserPrompt(payload);
+      if (!content) {
+        // Primary field path (field 19 → 2/3) missed. Recover schema-agnostically
+        // rather than silently drop a user turn: scan the payload for the longest
+        // plausible prompt run (metadata/paths/tokens are filtered out). There is
+        // no reasoning subtree to exclude on the user side.
+        const recovered = extractUserRequestContent(recoverMessageText(payload, []));
+        if (recovered) {
+          content = recovered;
+          LOG.debug(
+            'NativeHistory',
+            `antigravity .db ${path.basename(filePath)} step ${row.idx} (type ${row.step_type}): user prompt absent at field 19; recovered ${content.length} chars via printable-run fallback — possible step_payload schema drift`,
+          );
+        } else {
+          LOG.debug(
+            'NativeHistory',
+            `antigravity .db ${path.basename(filePath)} step ${row.idx} (type ${row.step_type}) dropped: no user prompt text (payload ${payload.length}B, top-level fields [${topLevelFieldNumbers(payload).join(',')}])`,
+          );
+          continue;
+        }
+      }
       const msg: NativeHistoryMessage = {
         ts: new Date(receivedAt).toISOString(),
         receivedAt,
@@ -692,8 +816,34 @@ function parseConversationDb(
       if (normalizedWorkspace) msg.workspace = normalizedWorkspace;
       messages.push(msg);
     } else if (row.step_type === AGY_STEP_TYPE_MODEL) {
-      const content = extractModelAnswer(payload);
-      if (!content) continue; // reasoning-only / tool-only model step — no answer text
+      let content = extractModelAnswer(payload);
+      if (!content) {
+        // The known answer path (field 20 → 1/8) yielded nothing. This is either
+        // (a) a legitimate reasoning-only / tool-planning step — the common case,
+        // which carries no user-visible answer — or (b) antigravity moved the
+        // answer to a different field/subtree (schema drift). Attempt a
+        // schema-agnostic recovery that EXCLUDES the reasoning subtree (field
+        // 20 → 3) so internal reasoning is never surfaced as the answer.
+        const reasoning = extractModelReasoning(payload);
+        const recovered = recoverMessageText(payload, reasoning ? [reasoning] : []);
+        if (recovered) {
+          content = recovered;
+          LOG.debug(
+            'NativeHistory',
+            `antigravity .db ${path.basename(filePath)} step ${row.idx} (type ${row.step_type}): answer absent at field 20; recovered ${content.length} chars via printable-run fallback — possible step_payload schema drift`,
+          );
+        } else {
+          // No answer at the primary path and nothing recoverable beyond
+          // reasoning/metadata → drop. Content-free breadcrumb so a genuine
+          // future drift (answer present but unreadable) is greppable, and the
+          // expected reasoning-only case is distinguishable via reasoningOnly.
+          LOG.debug(
+            'NativeHistory',
+            `antigravity .db ${path.basename(filePath)} step ${row.idx} (type ${row.step_type}) dropped: no answer text (payload ${payload.length}B, top-level fields [${topLevelFieldNumbers(payload).join(',')}], reasoningOnly=${reasoning ? 'yes' : 'no'})`,
+          );
+          continue;
+        }
+      }
       const msg: NativeHistoryMessage = {
         ts: new Date(receivedAt).toISOString(),
         receivedAt,