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

package/dist/mesh/mesh-ledger.d.ts

@@ -14,7 +14,7 @@
  */
 import { EventEmitter } from 'events';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned' | 'event_held' | 'task_reclaimed' | 'coordinator_operating_note' | 'mission_created' | 'mission_status_changed' | 'mission_goal_updated' | 'magi_dispatched' | 'magi_synthesis';
+export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned' | 'event_held' | 'task_reclaimed' | 'coordinator_operating_note' | 'coordinator_operating_note_tombstone' | 'mission_created' | 'mission_status_changed' | 'mission_goal_updated' | 'magi_dispatched' | 'magi_synthesis';
 export interface MeshLedgerEntry {
     id: string;
     meshId: string;
@@ -151,6 +151,10 @@ export interface AppendRemoteLedgerResult {
     entries: MeshLedgerEntry[];
 }
 export declare const MAX_LEDGER_SLICE_LIMIT = 500;
+export declare const OPERATING_NOTE_KIND: MeshLedgerKind;
+export declare const OPERATING_NOTE_TOMBSTONE_KIND: MeshLedgerKind;
+export declare const OPERATING_NOTE_DEDUPE_WINDOW = 40;
+export declare const OPERATING_NOTE_KEEP_LATEST = 100;
 export declare function getLedgerDir(): string;
 /**
  * Footer to append to worker task messages so workers output structured results
@@ -180,6 +184,40 @@ export declare function buildTaskCompletionEvidence(opts: BuildTaskCompletionEvi
  */
 export declare const meshLedgerEvents: EventEmitter<[never]>;
 export declare function appendLedgerEntry(meshId: string, partial: Omit<MeshLedgerEntry, 'id' | 'meshId' | 'timestamp'>): MeshLedgerEntry;
+/** True if the operating note is retracted by any tombstone in `tombstones`. */
+export declare function isOperatingNoteTombstoned(entry: Pick<MeshLedgerEntry, 'id' | 'payload'>, tombstones: {
+    ids: Set<string>;
+    fingerprints: Set<string>;
+}): boolean;
+/**
+ * Fix (2) supersede/remove: append a tombstone that retracts a coordinator
+ * operating note. Targets by note id and/or by exact trimmed text (a text target
+ * retracts every note with that text). History is preserved — the notes stay in
+ * the ledger but readers filter them out. Returns how many currently-live notes
+ * the tombstone will hide.
+ */
+export declare function tombstoneOperatingNote(meshId: string, target: {
+    noteId?: string;
+    text?: string;
+    reason?: string;
+}): {
+    tombstone: MeshLedgerEntry;
+    matched: number;
+};
+/**
+ * Read live operating notes (tombstoned notes filtered out), oldest→newest.
+ * `tail` bounds the number of live notes returned (the freshest N).
+ */
+export declare function readOperatingNotes(meshId: string, opts?: {
+    tail?: number;
+}): MeshLedgerEntry[];
+/**
+ * Fix (3) keep-latest-N prune for coordinator_operating_note. Removes, from the
+ * store, (a) every note retracted by a tombstone, and (b) the oldest live notes
+ * beyond `keepLatest`. Tombstone entries themselves are retained as an audit trail
+ * of what was forgotten. Returns the number of note entries removed.
+ */
+export declare function pruneOperatingNotes(meshId: string, keepLatest?: number): number;
 /**
  * Append entries received over local-first/P2P ledger replication to the local ledger.
  * This skips deduplicated entries and rejects malformed/cross-mesh entries.

package/dist/providers/cli-provider-instance.d.ts

@@ -286,6 +286,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private approvalResolutionFinalizationBlock;
     private scheduleCompletedDebounceFlush;
     private isMeshWorkerSession;
+    private isAutonomousMeshSession;
     /**
      * ARCH-REFACTOR R1: the taskId to attribute the CURRENTLY-completing turn to.
      * Prefers the per-turn binding (engine.currentTurnTaskId, set when the turn was

package/dist/providers/native-history/antigravity-cli-transcript.d.ts

@@ -12,11 +12,35 @@
  *        { source: 'USER_EXPLICIT'|'MODEL', type: string, content: string, status: 'DONE'|..., created_at: number }
  *
  *   3. ~/.gemini/antigravity-cli/conversations/<uuid>.pb
- *      Protobuf binary — schema not publicly documented. Adapter extracts
+ *      Legacy protobuf binary — schema not publicly documented. Adapter extracts
  *      printable UTF-8 text runs as best-effort content (no proto library needed).
  *
+ *   4. ~/.gemini/antigravity-cli/conversations/<uuid>.db  ← current format
+ *      Per-session SQLite database. Recent antigravity migrated conversation
+ *      storage from .pb (+ brain/*.jsonl) to a per-session SQLite db. The
+ *      schema is a trajectory of `steps`, NOT a simple messages(role,content)
+ *      table:
+ *        steps(idx INTEGER PK, step_type INTEGER, status INTEGER,
+ *              step_payload BLOB [protobuf], ...)
+ *      Each `step_payload` is a protobuf message. Empirically (introspected
+ *      from real stores):
+ *        - step_type 14 → a USER turn. The prompt text is the largest
+ *          contiguous UTF-8 run inside the payload (field 19 subtree).
+ *        - step_type 15 → a MODEL/assistant turn. The assistant's final
+ *          natural-language answer lives at payload field 20 → field 1
+ *          (identical to field 8). Field 20 → field 3 is the internal
+ *          reasoning summary and is intentionally NOT surfaced.
+ *        - other step types are tool calls / ephemeral system context.
+ *      We read the blobs with a tiny dependency-free protobuf field walker
+ *      (no proto schema / codegen needed) and map the two message step types.
+ *      Because the daemon does NOT read this db, native history previously
+ *      returned 0 rows for these sessions and read_chat fell back to the
+ *      pty parser (which only echoes the user's own input) — assistant
+ *      answers appeared lost even though they were on disk.
+ *
  * This adapter provides:
- *   - Full coverage when a brain transcript exists (authoritative source).
+ *   - Full coverage from a per-session .db (current format) — preferred.
+ *   - Full coverage when a brain transcript exists (legacy authoritative source).
  *   - Partial coverage (user prompts only) from history.jsonl as fallback.
  *   - Best-effort raw-string extraction from .pb files when no other source exists.
  *
@@ -24,6 +48,7 @@
  *   ~/.gemini/antigravity-cli/history.jsonl
  *   ~/.gemini/antigravity-cli/brain/{uuid}/.system_generated/logs/transcript*.jsonl
  *   ~/.gemini/antigravity-cli/conversations/{uuid}.pb
+ *   ~/.gemini/antigravity-cli/conversations/{uuid}.db
  *
  * OSS code (AGPL-3.0). Must not import from packages/ (proprietary).
  */
@@ -79,6 +104,7 @@ export interface NativeHistorySessionMeta {
  * `sessionPath` is the absolute path to one of:
  *   - A brain transcript JSONL: ~/.gemini/antigravity-cli/brain/<uuid>/.system_generated/logs/transcript*.jsonl
  *   - The shared history.jsonl: ~/.gemini/antigravity-cli/history.jsonl
+ *   - A conversation SQLite db: ~/.gemini/antigravity-cli/conversations/<uuid>.db
  *   - A conversation protobuf: ~/.gemini/antigravity-cli/conversations/<uuid>.pb
  *
  * The session UUID is inferred from the directory name (brain), filename (pb), or

package/package.json

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

package/src/commands/high-family/mesh-coordinator-launch.ts

@@ -101,8 +101,10 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
                     // Best-effort: a read failure just omits the section.
                     const buildOperatingNotesBestEffort = async (id: string) => {
                         try {
-                            const { readLedgerEntries } = await import('../../mesh/mesh-ledger.js');
-                            const noteEntries = readLedgerEntries(id, { kind: ['coordinator_operating_note'], tail: 20 });
+                            const { readOperatingNotes } = await import('../../mesh/mesh-ledger.js');
+                            // readOperatingNotes filters out tombstoned (forgotten) notes so a
+                            // retracted lesson never rides into the prompt. Newest last; tail 20.
+                            const noteEntries = readOperatingNotes(id, { tail: 20 });
                             const notes = noteEntries
                                 .map((e) => {
                                     const p = (e.payload || {}) as Record<string, unknown>;

package/src/index.ts

@@ -262,7 +262,7 @@ export { loadRepoSettings } from './config/repo-settings.js';
 export type { RepoSettings, LoadRepoSettingsOptions } from './config/repo-settings.js';
 
 // ── Mesh Task Ledger ──
-export { appendLedgerEntry, appendRemoteLedgerEntries, buildTaskCompletionEvidence, normalizeMeshWorkerResult, readLedgerEntries, readLedgerSlice, readLedgerSliceFromStore, getLedgerSummary, getLedgerDir, getSessionRecoveryContext, MAX_LEDGER_SLICE_LIMIT } from './mesh/mesh-ledger.js';
+export { appendLedgerEntry, appendRemoteLedgerEntries, buildTaskCompletionEvidence, normalizeMeshWorkerResult, readLedgerEntries, readLedgerSlice, readLedgerSliceFromStore, getLedgerSummary, getLedgerDir, getSessionRecoveryContext, MAX_LEDGER_SLICE_LIMIT, tombstoneOperatingNote, readOperatingNotes, pruneOperatingNotes, isOperatingNoteTombstoned, OPERATING_NOTE_KIND, OPERATING_NOTE_TOMBSTONE_KIND, OPERATING_NOTE_DEDUPE_WINDOW, OPERATING_NOTE_KEEP_LATEST } from './mesh/mesh-ledger.js';
 export type { AppendRemoteLedgerResult, MeshLedgerEntry, MeshLedgerKind, MeshLedgerSlice, MeshLedgerSummary, ReadLedgerOptions, ReadLedgerSliceOptions, SessionRecoveryContext, MeshTaskCompletionEvidence, MeshWorkerResultArtifact, MeshProcessArtifact, MeshValidationResultArtifact } from './mesh/mesh-ledger.js';
 export { fastForwardMeshNode } from './mesh/mesh-fast-forward.js';
 export type { MeshFastForwardNodeArgs, MeshFastForwardPlannedStep, MeshFastForwardResult } from './mesh/mesh-fast-forward.js';

package/src/mesh/coordinator-prompt.ts

@@ -490,6 +490,7 @@ const TOOLS_SECTION = `## Available Tools
 | \`mesh_read_debug\` | Collect a daemon-side chat/parser debug bundle for a session |
 | \`mesh_task_history\` | Read the task ledger — dispatches, completions, failures. Use to understand what has been done before deciding next steps |
 | \`mesh_record_note\` | Record a durable, provider-neutral operating note (provider quirk / pattern to avoid / recovery lesson). Future coordinators see it under "## Operating Notes" at launch |
+| \`mesh_forget_note\` | Retract a stale/wrong operating note by note_id or exact text so it stops riding into future coordinators' prompts (append-only tombstone; history preserved) |
 | \`mesh_git_status\` | Check git status on a specific node |
 | \`mesh_read_node_logs\` | Fetch a remote node's daemon log tail directly over P2P (grep/since/byte-bounded, secrets redacted) — no session/PowerShell needed to debug a node's daemon |
 | \`mesh_fast_forward_node\` | Safely dry-run or explicitly execute an obvious clean fast-forward without launching an agent session |

package/src/mesh/mesh-ledger.ts

@@ -49,6 +49,11 @@ export type MeshLedgerKind =
     // the ledger so it survives coordinator restarts and is provider-neutral.
     // payload: { text, category?, createdAt?, sourceCoordinator? }
     | 'coordinator_operating_note'
+    // Retraction of a coordinator_operating_note. Append-only (history preserved);
+    // readers filter out the targeted note so it leaves the prompt/list. Targets by
+    // note id (exact) and/or by trimmed-text fingerprint (matches all notes with that
+    // text). payload: { targetNoteId?, targetFingerprint?, reason?, forgottenAt? }
+    | 'coordinator_operating_note_tombstone'
     // Mission audit trail: mission record mutations (mesh_mission_upsert) so the
     // ledger captures mission lifecycle, not just task events. Without these a
     // mission create / goal rewrite / status transition left no ledger trace,
@@ -253,6 +258,32 @@ const ARCHIVABLE_KINDS: ReadonlySet<MeshLedgerKind> = new Set([
 const DEFAULT_LEDGER_SLICE_LIMIT = 100;
 export const MAX_LEDGER_SLICE_LIMIT = 500;
 
+// ─── Operating-note growth control ──────────────
+// coordinator_operating_note is append-only and, unlike task_* entries, is never
+// archived by compactLedger (it is not in ARCHIVABLE_KINDS — it must survive
+// restarts and there is no time-based cutoff for a "lesson"). Without dedicated
+// controls the note set grows without bound and duplicate/stale notes crowd the
+// bounded tail that rides into the coordinator prompt. These three constants back
+// the three growth controls: dedupe-on-record, tombstone/forget, keep-latest-N.
+
+// Kind marking an operating note as retracted. A tombstone is itself an
+// append-only ledger entry (history is never destroyed); readers filter out the
+// notes it targets. payload: { targetNoteId?, targetFingerprint?, reason? }
+export const OPERATING_NOTE_KIND: MeshLedgerKind = 'coordinator_operating_note';
+export const OPERATING_NOTE_TOMBSTONE_KIND: MeshLedgerKind = 'coordinator_operating_note_tombstone';
+
+// Dedupe window: when recording a note, if the same trimmed text already appears
+// among the most recent OPERATING_NOTE_DEDUPE_WINDOW notes, the record is a no-op
+// (the existing entry is returned). Keeps the prompt tail from filling with the
+// same lesson recorded 20 times.
+export const OPERATING_NOTE_DEDUPE_WINDOW = 40;
+
+// Keep-latest-N: pruneOperatingNotes retains at most this many live (non-tombstoned)
+// operating notes, removing the oldest surplus and any tombstoned notes from the
+// store. The prompt reads a much smaller tail (20), so this bound never trims what
+// a coordinator actually sees while still capping unbounded store growth.
+export const OPERATING_NOTE_KEEP_LATEST = 100;
+
 // ─── Path Helpers ───────────────────────────────
 
 export function getLedgerDir(): string {
@@ -605,6 +636,23 @@ export function appendLedgerEntry(
     meshId: string,
     partial: Omit<MeshLedgerEntry, 'id' | 'meshId' | 'timestamp'>,
 ): MeshLedgerEntry {
+    // Fix (1) dedupe-on-record: for a coordinator_operating_note, if the same
+    // trimmed text already appears among the most recent OPERATING_NOTE_DEDUPE_WINDOW
+    // notes, do NOT append a duplicate — return the existing entry so the bounded
+    // prompt tail can't be crowded by the same lesson recorded repeatedly. Other
+    // kinds (task_completed, …) are untouched.
+    if (partial.kind === OPERATING_NOTE_KIND) {
+        const text = operatingNoteText(partial.payload);
+        if (text) {
+            const recentNotes = readLedgerEntries(meshId, {
+                kind: [OPERATING_NOTE_KIND],
+                tail: OPERATING_NOTE_DEDUPE_WINDOW,
+            });
+            const existing = recentNotes.find(e => operatingNoteText(e.payload) === text);
+            if (existing) return existing;
+        }
+    }
+
     const entry: MeshLedgerEntry = {
         id: randomUUID(),
         meshId,
@@ -653,12 +701,149 @@ export function appendLedgerEntry(
         appendFileSync(filePath, line, { encoding: 'utf-8', mode: 0o600 });
         invalidateLedgerCache(meshId);
         meshLedgerEvents.emit('append', meshId, entry);
+        // Fix (3) keep-latest-N: operating notes are never archived by compactLedger,
+        // so cap their store footprint here. Runs only when a note (or its tombstone)
+        // is recorded, and is a no-op until the live-note count exceeds the bound.
+        if (entry.kind === OPERATING_NOTE_KIND || entry.kind === OPERATING_NOTE_TOMBSTONE_KIND) {
+            try { pruneOperatingNotes(meshId); } catch { /* prune is best-effort */ }
+        }
         return entry;
     } catch (e: any) {
         throw new Error(`Failed to append to ledger for mesh ${meshId}: ${e.message}`);
     }
 }
 
+// ─── Operating-note growth controls ─────────────
+
+/** Extract the trimmed note text from a coordinator_operating_note payload. */
+function operatingNoteText(payload: Record<string, unknown> | undefined): string | undefined {
+    const text = payload && typeof payload.text === 'string' ? payload.text.trim() : '';
+    return text || undefined;
+}
+
+/**
+ * Set of trimmed-text fingerprints and note ids retracted by tombstone entries in
+ * the given entry set. A tombstone targets by note id and/or by text fingerprint.
+ */
+function collectOperatingNoteTombstones(entries: MeshLedgerEntry[]): { ids: Set<string>; fingerprints: Set<string> } {
+    const ids = new Set<string>();
+    const fingerprints = new Set<string>();
+    for (const e of entries) {
+        if (e.kind !== OPERATING_NOTE_TOMBSTONE_KIND) continue;
+        const p = e.payload || {};
+        const targetId = typeof p.targetNoteId === 'string' ? p.targetNoteId.trim() : '';
+        const targetFp = typeof p.targetFingerprint === 'string' ? p.targetFingerprint.trim() : '';
+        if (targetId) ids.add(targetId);
+        if (targetFp) fingerprints.add(targetFp);
+    }
+    return { ids, fingerprints };
+}
+
+/** True if the operating note is retracted by any tombstone in `tombstones`. */
+export function isOperatingNoteTombstoned(
+    entry: Pick<MeshLedgerEntry, 'id' | 'payload'>,
+    tombstones: { ids: Set<string>; fingerprints: Set<string> },
+): boolean {
+    if (tombstones.ids.has(entry.id)) return true;
+    const text = operatingNoteText(entry.payload);
+    return text ? tombstones.fingerprints.has(text) : false;
+}
+
+/**
+ * Fix (2) supersede/remove: append a tombstone that retracts a coordinator
+ * operating note. Targets by note id and/or by exact trimmed text (a text target
+ * retracts every note with that text). History is preserved — the notes stay in
+ * the ledger but readers filter them out. Returns how many currently-live notes
+ * the tombstone will hide.
+ */
+export function tombstoneOperatingNote(
+    meshId: string,
+    target: { noteId?: string; text?: string; reason?: string },
+): { tombstone: MeshLedgerEntry; matched: number } {
+    const noteId = typeof target.noteId === 'string' ? target.noteId.trim() : '';
+    const fingerprint = typeof target.text === 'string' ? target.text.trim() : '';
+    if (!noteId && !fingerprint) {
+        throw new Error('tombstoneOperatingNote requires a noteId or text target');
+    }
+
+    // Count currently-live matches (not already tombstoned) for the caller's report.
+    const notes = readOperatingNotes(meshId);
+    const matched = notes.filter(n =>
+        (noteId && n.id === noteId) || (fingerprint && operatingNoteText(n.payload) === fingerprint),
+    ).length;
+
+    const tombstone = appendLedgerEntry(meshId, {
+        kind: OPERATING_NOTE_TOMBSTONE_KIND,
+        payload: {
+            ...(noteId ? { targetNoteId: noteId } : {}),
+            ...(fingerprint ? { targetFingerprint: fingerprint } : {}),
+            ...(target.reason && target.reason.trim() ? { reason: target.reason.trim() } : {}),
+            forgottenAt: new Date().toISOString(),
+        },
+    });
+    return { tombstone, matched };
+}
+
+/**
+ * Read live operating notes (tombstoned notes filtered out), oldest→newest.
+ * `tail` bounds the number of live notes returned (the freshest N).
+ */
+export function readOperatingNotes(meshId: string, opts?: { tail?: number }): MeshLedgerEntry[] {
+    const raw = getCachedRawEntries(meshId);
+    const tombstones = collectOperatingNoteTombstones(raw);
+    let notes = raw.filter(e => e.kind === OPERATING_NOTE_KIND && !isOperatingNoteTombstoned(e, tombstones));
+    if (opts?.tail && opts.tail > 0 && notes.length > opts.tail) {
+        notes = notes.slice(-opts.tail);
+    }
+    return notes;
+}
+
+/**
+ * Fix (3) keep-latest-N prune for coordinator_operating_note. Removes, from the
+ * store, (a) every note retracted by a tombstone, and (b) the oldest live notes
+ * beyond `keepLatest`. Tombstone entries themselves are retained as an audit trail
+ * of what was forgotten. Returns the number of note entries removed.
+ */
+export function pruneOperatingNotes(meshId: string, keepLatest: number = OPERATING_NOTE_KEEP_LATEST): number {
+    const raw = getCachedRawEntries(meshId);
+    const tombstones = collectOperatingNoteTombstones(raw);
+
+    const removeIds: string[] = [];
+    const liveNotes: MeshLedgerEntry[] = [];
+    for (const e of raw) {
+        if (e.kind !== OPERATING_NOTE_KIND) continue;
+        if (isOperatingNoteTombstoned(e, tombstones)) {
+            removeIds.push(e.id); // tombstoned notes are pruned first
+        } else {
+            liveNotes.push(e);
+        }
+    }
+
+    // Drop the oldest live notes beyond keepLatest; the freshest (prompt tail) survive.
+    const bound = Math.max(0, Math.floor(keepLatest));
+    if (liveNotes.length > bound) {
+        for (const e of liveNotes.slice(0, liveNotes.length - bound)) removeIds.push(e.id);
+    }
+
+    if (removeIds.length === 0) return 0;
+
+    try {
+        MeshRuntimeStore.getInstance().deleteLedgerEntries(meshId, removeIds);
+    } catch { /* store unavailable — JSONL rewrite below still trims */ }
+
+    // Rewrite the JSONL mirror without the pruned note entries so the export
+    // artifact stays consistent with the store.
+    try {
+        const remaining = readLedgerFile(meshId).filter(e => !removeIds.includes(e.id));
+        const filePath = getLedgerPath(meshId);
+        const lines = remaining.length ? remaining.map(e => JSON.stringify(e)).join('\n') + '\n' : '';
+        writeFileSync(filePath, lines, { encoding: 'utf-8', mode: 0o600 });
+    } catch { /* JSONL rewrite best-effort; store is the primary read path */ }
+
+    invalidateLedgerCache(meshId);
+    return removeIds.length;
+}
+
 function clampLedgerSliceLimit(limit: unknown): number {
     if (typeof limit !== 'number' || !Number.isFinite(limit)) return DEFAULT_LEDGER_SLICE_LIMIT;
     return Math.max(1, Math.min(MAX_LEDGER_SLICE_LIMIT, Math.floor(limit)));

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

@@ -1207,8 +1207,7 @@ export class CliProviderInstance implements ProviderInstance {
      * to the genuine-modal classification.
      */
     private isTransientToolConsent(now = Date.now()): boolean {
-        const isAutonomousMeshSession = this.isMeshWorkerSession() || !!this.settings.meshCoordinatorFor;
-        return isAutonomousMeshSession
+        return this.isAutonomousMeshSession()
             && this.hasAdapterPendingResponse()
             && !this.manualAttendance.isAttended(now);
     }
@@ -1841,6 +1840,20 @@ export class CliProviderInstance implements ProviderInstance {
             || this.settings.meshNodeId || this.settings.launchedByCoordinator);
     }
 
+    // FALSE-IDLE (self-coordinator settle): an autonomously-progressing mesh session
+    // is either a delegated worker (isMeshWorkerSession) OR the coordinator's OWN
+    // claude-cli session (meshCoordinatorFor). Both run auto-approved tool turns whose
+    // inter-approval valley (busy→idle blip→generating re-entry ~0.5s later) must be
+    // absorbed by the completedDebounce settle window, not flushed on the first idle
+    // sample. The worker branch already gets NATIVE_HISTORY_MESH_IDLE_SETTLE_MS; the
+    // self-coordinator session (worker markers absent, meshCoordinatorFor present) was
+    // taking flushDelay=0 — no settle window — so its busyEpoch/lastOutputAt continuity
+    // guard had no window to observe the valley and fired mid-turn "next-step" previews
+    // as a finalSummary. Mirrors the isAutonomousMeshSession notion in isTransientToolConsent.
+    private isAutonomousMeshSession(): boolean {
+        return this.isMeshWorkerSession() || !!this.settings.meshCoordinatorFor;
+    }
+
     /**
      * ARCH-REFACTOR R1: the taskId to attribute the CURRENTLY-completing turn to.
      * Prefers the per-turn binding (engine.currentTurnTaskId, set when the turn was
@@ -2623,16 +2636,29 @@ export class CliProviderInstance implements ProviderInstance {
                     };
                     const ownsExternalHistory = !!(this.adapter as any)?.chatMessagesOwnedExternally;
                     // (FALSEIDLE-BGCHILD-a) Native-history providers flush immediately (the
-                    // transcript is authoritative). For mesh worker sessions, give the
-                    // generating→idle transition a short settle window so a background-child
+                    // transcript is authoritative). For autonomously-progressing mesh sessions,
+                    // give the generating→idle transition a short settle window so a background-child
                     // false idle (quiet after a backgrounded test/command while the parent turn
-                    // continues) gets caught by the resume guard in flushCompletedDebounceIfFinalized
-                    // instead of firing an early completion the coordinator can never correct.
-                    const meshWorkerSession = this.isMeshWorkerSession();
+                    // continues) or an inter-approval auto-approve valley gets caught by the resume
+                    // guard in flushCompletedDebounceIfFinalized instead of firing an early completion
+                    // the coordinator can never correct.
+                    //
+                    // (FALSE-IDLE self-coordinator settle) The settle window now covers BOTH mesh
+                    // worker sessions AND the coordinator's own claude-cli session (meshCoordinatorFor):
+                    // isAutonomousMeshSession(). Previously only isMeshWorkerSession() qualified, so a
+                    // self-coordinating daemon (worker + coordinator on the same daemon) ran the
+                    // coordinator's own turn at flushDelay=0 — no settle window at all — and the
+                    // busyEpoch/lastOutputAt continuity guard, being a flush-time point-check, had no
+                    // window in which to observe the ~0.5s auto-approve valley. Its mid-turn
+                    // "next-step" sentence was flushed as finalSummary. A genuinely non-mesh session
+                    // (neither worker nor self-coordinator) still flushes immediately (delay=0), so
+                    // no non-mesh behaviour changes; this only ADDS a settle window (strictly
+                    // stricter — the guard can only ever CANCEL a pending flush, never emit more).
+                    const meshSettleSession = this.isAutonomousMeshSession();
                     const flushDelay = ownsExternalHistory
-                        ? (meshWorkerSession ? NATIVE_HISTORY_MESH_IDLE_SETTLE_MS : 0)
+                        ? (meshSettleSession ? NATIVE_HISTORY_MESH_IDLE_SETTLE_MS : 0)
                         : 3000;
-                    LOG.debug('CLI', `[${this.type}] set completedDebouncePending duration=${duration}s ownsExternalHistory=${ownsExternalHistory} meshWorker=${meshWorkerSession} flushDelay=${flushDelay}ms generatingStartedAt=${this.generatingStartedAt}`);
+                    LOG.debug('CLI', `[${this.type}] set completedDebouncePending duration=${duration}s ownsExternalHistory=${ownsExternalHistory} meshSettle=${meshSettleSession} flushDelay=${flushDelay}ms generatingStartedAt=${this.generatingStartedAt}`);
                     this.scheduleCompletedDebounceFlush(flushDelay);
                 }
             } else if (newStatus === 'idle' && this.lastStatus === 'starting') {