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

package/dist/mesh/mesh-queue-assignment.d.ts

@@ -3,6 +3,12 @@ import type { RepoMeshSchedulingStrategy } from '../repo-mesh-types.js';
 export declare function __resetIdleAutoFastForwardForTests(): void;
 export declare function getMeshWithCache(components: DaemonComponents, meshId: string): any | undefined;
 export declare function tryAssignQueueTask(components: DaemonComponents, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
+interface AwaitClaimBackoffState {
+    cycles: number;
+    nextAttemptAtMs: number;
+}
+export declare function __resetAutoLaunchAwaitClaimBackoffForTests(): void;
+export declare function __seedAutoLaunchAwaitClaimBackoffForTests(meshId: string, taskId: string, state: AwaitClaimBackoffState): void;
 /** Active assignments that hold the one-active-per-node / global-parallel invariant
  *  (everything except read-only diagnoses, which run unbounded by the write cap). */
 export declare function activeWriteAssignedCount(meshId: string): number;
@@ -65,6 +71,28 @@ export declare function sessionHasActiveAssignment(meshId: string, sessionId: st
  * dead/stale session is not generating → returns false → the requeue proceeds as before.
  */
 export declare function isSessionActivelyGenerating(components: DaemonComponents, sessionId: string): boolean;
+/**
+ * RECLAIM-FALSEPOS tri-state busy verdict for a session id.
+ *
+ * The binary isSessionActivelyGenerating() folds "absence of a positive generating
+ * signal" into a definitive NEGATIVE (returns false when the instance is absent). But a
+ * REMOTE session (never in THIS daemon's instanceManager) — or a locally-present session
+ * looked up under a skewed id form — then looks "not generating" and can be reclaimed out
+ * from under a worker that is genuinely mid-turn. This resolves an explicit three-way
+ * verdict instead:
+ *   - GENERATING       — a locally-present instance reports an active/streaming state.
+ *   - IDLE_CONFIRMED    — a locally-present instance reports a non-active (idle/terminal)
+ *                         state. Positive local evidence the worker is not working.
+ *   - UNKNOWN           — no locally-present instance matches (remote / gone / id-skew) or
+ *                         the observation failed. NEVER treated as IDLE_CONFIRMED.
+ *
+ * The lookup scans getByCategory('cli') with sessionIdsEquivalent (the same equivalence
+ * matching nodeHasActiveMeshWork / liveSessionCountForNode use) rather than a raw
+ * instanceManager.getInstance(id) Map.get, so an id-form-skewed but present session is
+ * found (closing the same id-form-skew hole class e245c2f9's F1 fixed elsewhere).
+ */
+export type SessionBusyVerdict = 'GENERATING' | 'IDLE_CONFIRMED' | 'UNKNOWN';
+export declare function resolveSessionBusyVerdict(components: DaemonComponents, sessionId: string): SessionBusyVerdict;
 export interface MeshQueueTriggerResult {
     success: true;
     meshId: string;

package/dist/mesh/mesh-reconcile-loop.d.ts

@@ -70,6 +70,7 @@ export declare function resolveCoordinatorDrainDeliverability(components: Pick<D
 export declare function shouldHoldPendingDrainForBusyLocalCoordinator(components: Pick<DaemonComponents, 'instanceManager'> & {
     statusInstanceId?: string;
 }, meshId: string, requestedCoordinatorDaemonId?: string | null, callerIsSelfCoordinatorInboxRead?: boolean): boolean;
+export declare function __resetReclaimUnknownStreakForTests(): void;
 export declare function runMeshReconcileTick(components: DaemonComponents): Promise<void>;
 export declare function __resetUnresolvedForwardRejectionCountsForTests(): void;
 interface ReconcileLoopHandle {

package/dist/providers/chat-message-normalization.d.ts

@@ -32,6 +32,32 @@ export declare function extractFinalAssistantSummaryEvidence(messages: ChatMessa
     finalSummary: string;
     transcriptMessageAt?: string;
 };
+/**
+ * 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 declare function selectFinalAssistantTurnEndMessage(messages: ChatMessage[] | null | undefined): ChatMessage | null;
 export declare const BUILTIN_CHAT_MESSAGE_KINDS: readonly ["standard", "thought", "tool", "terminal", "system"];
 export type BuiltinChatMessageKind = typeof BUILTIN_CHAT_MESSAGE_KINDS[number];
 export type ChatMessageKind = BuiltinChatMessageKind | (string & {});

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

@@ -268,6 +268,13 @@ export declare class CliProviderInstance implements ProviderInstance {
     recordAcknowledgedUserInput(input: InputEnvelope | string): void;
     /** Drop user-input ack entries older than the dedup window so the map can't grow unbounded. */
     private pruneRecentUserInputAcks;
+    /**
+     * 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;
     dispose(): void;
     private completedDebounceTimer;
     private completedDebouncePending;

package/dist/providers/native-history/antigravity-claim-registry.d.ts

@@ -0,0 +1,28 @@
+/** A claim older than this with no refresh is reclaimable (owner presumed dead). */
+export declare const CLAIM_STALE_MS: number;
+/**
+ * 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 declare function antigravityOwnerToken(workspace: string, sessionStartedAtMs: number, instanceId?: string): string;
+/**
+ * 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 declare function claimAntigravityConversation(uuid: string, owner: string, now?: number): boolean;
+/** True when `uuid` is held by a live owner OTHER than `owner`. */
+export declare function isAntigravityConversationClaimedByOther(uuid: string, owner: string, now?: number): boolean;
+/** The live owner of `uuid`, or undefined when unclaimed or stale. */
+export declare function antigravityConversationOwner(uuid: string, now?: number): string | undefined;
+/** Release a single conversation, only if held by `owner` (or `owner` empty). */
+export declare function releaseAntigravityConversation(uuid: string, owner?: string): void;
+/** Release every conversation held by `owner` (called on session shutdown). */
+export declare function releaseAntigravityOwner(owner: string): void;
+/** Test-only: wipe all claims so each test starts from a clean registry. */
+export declare function __resetAntigravityClaimRegistry(): void;

package/dist/providers/native-history/antigravity-cli-transcript.d.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).

package/dist/providers/native-history/dispatcher.d.ts

@@ -4,6 +4,10 @@ export interface NativeHistoryInput {
     sessionId?: string;
     providerSessionId?: string;
     historySessionId?: string;
+    /** Daemon instance id of the reading session. Used (with workspace +
+     *  sessionStartedAtMs) to derive the antigravity conversation-claim owner
+     *  token so two concurrent sessions never bind to the same .db. */
+    instanceId?: string;
     workspace?: string;
     sessionStartedAtMs?: number;
     format?: string;

package/package.json

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

package/src/mesh/mesh-events-stale.ts

@@ -4,8 +4,19 @@ import { updateDirectDispatchStatus, cleanupTerminalDirectDispatches } from './m
 import { markSessionDeliveriesTerminal } from './mesh-delivery-policy.js';
 import { queuePendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import { readNonEmptyString, readRecord, resolveEventSessionId, readWorkerResultMetadata, isWeakCompletionEvidence, buildMeshSystemMessage } from './mesh-events-utils.js';
+import { recordDebugTrace } from '../logging/debug-trace.js';
 import { meshNodeIdMatches, sessionIdsEquivalent, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 
+// EARLYNOTIFY-GATEBYPASS (d): every completed-emit producer that bypasses the CLI-provider
+// completion gate (transcript-reconcile synth here, no-progress reconcile below, the fast-collapse
+// synth in cli-provider-instance) records a completion-gate trace so a synthesized "completed and
+// idle" emit can never again be silent. Content-free by construction — keyed by taskId + source
+// only, never worker/screen text. completion-gate is an ALWAYS_ON_TRACE_CATEGORY, so recordDebugTrace
+// self-gates and lands in the ring even on a production daemon.
+function recordSynthCompletionGateTrace(stage: string, payload: Record<string, unknown>): void {
+    recordDebugTrace({ category: 'completion-gate', stage, level: 'debug', payload });
+}
+
 // ---------------------------------------------------------------------------
 // Stale direct-dispatch detection & transcript reconciliation
 // ---------------------------------------------------------------------------
@@ -232,6 +243,14 @@ export function reconcileDirectDispatchCompletionFromTranscript(args: {
         completedAt,
     });
     const workerResult = evidence.workerResult;
+    // EARLYNOTIFY-GATEBYPASS (c): a transcript-reconcile synth is TENTATIVE unless the worker's
+    // summary self-attributes to this turn — i.e. it parsed a worker-result-shaped JSON
+    // (`final_summary_json`), the same self-attribution the grace gate below exempts. A plain-text
+    // transcript tail proves neither turn-finality nor that this reconcile beat the real completion,
+    // so it is marked WEAK: buildPendingEventFingerprint then keys it `…::weak`, leaving the
+    // `…::genuine` slot free for the worker's own later agent:generating_completed to surface (the
+    // CANON-B weak→genuine supersession) instead of being dropped as a duplicate.
+    const selfAttributing = workerResult.source === 'final_summary_json';
     const dispatchTime = dispatch?.timestamp ? new Date(dispatch.timestamp).getTime() : Number.NaN;
     const transcriptTime = args.transcriptMessageAt ? new Date(args.transcriptMessageAt).getTime() : Number.NaN;
     const transcriptAfterDispatch = Number.isFinite(dispatchTime) && Number.isFinite(transcriptTime) && transcriptTime >= dispatchTime;
@@ -281,7 +300,9 @@ export function reconcileDirectDispatchCompletionFromTranscript(args: {
                 dispatchEntryId: dispatch?.id,
                 dispatchTimestamp: dispatch?.timestamp,
                 transcriptMessageAt: readNonEmptyString(args.transcriptMessageAt),
-                transcriptFinalAssistantPresent: true,
+                // Honestly reflect self-attribution: a plain-text tail did NOT prove a turn-final
+                // assistant message (only a self-attributing final_summary_json did).
+                transcriptFinalAssistantPresent: selfAttributing,
             },
             evidence,
         },
@@ -308,6 +329,11 @@ export function reconcileDirectDispatchCompletionFromTranscript(args: {
         finalSummary,
         taskId: args.taskId,
         workerResult,
+        // EARLYNOTIFY-GATEBYPASS (c): mark a non-self-attributing synth WEAK so its pending
+        // fingerprint is `…::weak` (isWeakCompletionMetadata reads evidenceLevel), never claiming
+        // the genuine dedup slot. evidenceLevel:'weak' is deliberately NOT a false-idle marker
+        // (the transcript tail existed) — it keeps the completion superseable, not suppressed.
+        ...(selfAttributing ? {} : { evidenceLevel: 'weak' as const }),
         completionDiagnostic: {
             reason: 'direct_task_transcript_reconciliation',
             terminalLedgerKind: kind,
@@ -331,6 +357,16 @@ export function reconcileDirectDispatchCompletionFromTranscript(args: {
         ...(targetCoordinatorSessionId ? { targetCoordinatorSessionId } : {}),
     });
 
+    // (d) The synth fired — record it so this gate-bypassing emit is observable.
+    recordSynthCompletionGateTrace('synth-fire', {
+        producer: 'transcript_reconcile',
+        source: args.source || 'direct_task_transcript_reconciliation',
+        taskId: args.taskId,
+        kind,
+        selfAttributing,
+        evidenceLevel: selfAttributing ? 'sufficient' : 'weak',
+    });
+
     return { reconciled: true, kind, workerResult, ledgerEntryId: entry.id };
 }
 
@@ -349,15 +385,29 @@ export function buildNoProgressCompletionReconciliation(args: {
     const completionDiagnostic = readRecord(args.metadataEvent.completionDiagnostic);
     const finalSummary = readNonEmptyString(args.metadataEvent.finalSummary);
     const status = readNonEmptyString(args.metadataEvent.status).toLowerCase();
+    // EARLYNOTIFY-GATEBYPASS (c): a bare status flag (idle/ready/completed) with NO worker text is
+    // the weakest possible "done" evidence — it is exactly the false-idle the no-progress monitor
+    // fires on. Only a real assistant summary / worker result / confirmed final-assistant makes this
+    // reconcile self-attributing. When it is not, mark the synthesized completion WEAK so a later
+    // genuine completion can still supersede it (and buildMeshSystemMessage appends a verify hint).
+    const noProgressSelfAttributing = Boolean(
+        finalSummary || workerResult || completionDiagnostic?.finalAssistantPresent === true,
+    );
     const explicitCompletionEvidence = Boolean(
-        finalSummary
-        || workerResult
-        || completionDiagnostic?.finalAssistantPresent === true
+        noProgressSelfAttributing
         || status === 'idle'
         || status === 'ready'
         || status === 'completed',
     );
     if (explicitCompletionEvidence) {
+        // (d) A no-progress→completion synth bypasses the CLI provider gate — trace it.
+        recordSynthCompletionGateTrace('synth-fire', {
+            producer: 'no_progress_reconcile',
+            source: 'no_progress_reconciliation',
+            taskId: readNonEmptyString(args.metadataEvent.taskId),
+            selfAttributing: noProgressSelfAttributing,
+            evidenceLevel: noProgressSelfAttributing ? 'sufficient' : 'weak',
+        });
         return {
             ...args.metadataEvent,
             targetSessionId: sessionId,
@@ -367,6 +417,7 @@ export function buildNoProgressCompletionReconciliation(args: {
             source: 'no_progress_reconciliation',
             reconciledFromEvent: 'monitor:no_progress',
             timestamp: args.metadataEvent.timestamp ?? Date.now(),
+            ...(noProgressSelfAttributing ? {} : { evidenceLevel: 'weak' as const }),
             completionDiagnostic: {
                 ...(completionDiagnostic || {}),
                 reconciliationReason: 'provider_completion_evidence',

package/src/mesh/mesh-queue-assignment.ts

@@ -606,6 +606,80 @@ const AUTO_LAUNCH_COOLDOWN_MS = 5_000;
 // seconds) but bounded so a launch that silently never reaches idle is eventually retried.
 const AUTO_LAUNCH_AWAIT_CLAIM_MS = 90_000;
 
+// AUTOLAUNCH-CLAIM-CHURN. For a REMOTE node the launch→claim handshake is purely
+// event-sourced: the worker's agent:ready must be pulled (reconcile PHASE 1) to run
+// setRemoteIdleSession before the drain can claim. If that pull is lost, nothing recovers,
+// and after AUTO_LAUNCH_AWAIT_CLAIM_MS the loop used to blindly RESPAWN a new session — whose
+// respawn guards (nodeHasLiveSessionPendingClaim / liveSessionCountForNode) scan only the LOCAL
+// instanceManager, so the remote pending-claim session is invisible and a fresh ghost accumulates
+// every ~90s (observed live 2026-07-04: task 8b188c64, and 7 ghost sessions on this worktree's
+// own task at 11:23-11:34). Instead of respawning on window expiry, we re-drive the claim for the
+// EXISTING session; when its liveness cannot be positively determined we EXTEND the window with
+// exponential backoff (90 → 180 → 360s) and, only after the cap, deliver the task directly into
+// the launched session (the mesh_send_task-equivalent) rather than spawning another worker.
+const AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES = 2;
+// Local mirror of REMOTE_IDLE_SESSION_TTL_MS (mesh-event-forwarding) — kept here to avoid a
+// cross-module import cycle. Used when (re)registering a launched remote session as an idle
+// claim candidate during the await-claim re-drive.
+const AUTO_LAUNCH_REMOTE_IDLE_TTL_MS = 5 * 60 * 1000;
+
+// Per-task await-claim backoff state, keyed `${meshId}::${taskId}`. `cycles` counts how many
+// times the window has been extended; `nextAttemptAtMs` rate-limits the re-drive to the backoff
+// cadence so the 4s reconcile tick does not hammer it. Cleared once the task claims, the direct
+// dispatch fires, or a respawn is authorized. In-memory (per process); a stale entry is harmless
+// (it only defers a respawn) and self-clears on the next resolution.
+interface AwaitClaimBackoffState { cycles: number; nextAttemptAtMs: number; }
+const autoLaunchAwaitClaimBackoff = new Map<string, AwaitClaimBackoffState>();
+
+// Test hooks: reset / seed the await-claim backoff state between cases.
+export function __resetAutoLaunchAwaitClaimBackoffForTests(): void {
+    autoLaunchAwaitClaimBackoff.clear();
+}
+export function __seedAutoLaunchAwaitClaimBackoffForTests(meshId: string, taskId: string, state: AwaitClaimBackoffState): void {
+    autoLaunchAwaitClaimBackoff.set(`${meshId}::${taskId}`, { ...state });
+}
+
+// Backoff window for a given cycle count: 90 → 180 → 360s (capped at the cap-cycle multiplier).
+function awaitClaimWindowMs(cycles: number): number {
+    return AUTO_LAUNCH_AWAIT_CLAIM_MS * Math.pow(2, Math.min(cycles, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES));
+}
+
+// Does the coordinator's remote-session view (MeshRuntimeStore remote idle sessions, populated by
+// mesh event forwarding) currently show this session as a live idle claim candidate? Positive
+// evidence the launched remote session is reachable — used to re-drive its claim directly instead
+// of respawning. Absence is NOT proof the session is gone (the agent:ready pull may simply have
+// been lost), so callers treat a false here as UNKNOWN liveness, never a definitive terminal.
+function remoteSessionAppearsLive(meshId: string, sessionId: string): boolean {
+    if (!sessionId) return false;
+    try {
+        return MeshRuntimeStore.getInstance().getRemoteIdleSessions(meshId)
+            .some(s => sessionIdsEquivalent(s.sessionId, sessionId));
+    } catch {
+        return false;
+    }
+}
+
+// (A) Respawn-guard remote-awareness. The session ids of pending tasks whose auto-launch record
+// targets `nodeId` (status started/completed with a sessionId) and is still inside its await-claim
+// window — the base 90s window OR an active backoff extension. Such a session is ALREADY on its way
+// to claim even when it is REMOTE (invisible to this daemon's instanceManager), so counting it
+// suppresses a duplicate launch that would otherwise spawn a ghost.
+function inWindowAutoLaunchSessionIdsForNode(meshId: string, nodeId: string): string[] {
+    const nowMs = Date.now();
+    const out: string[] = [];
+    for (const task of getQueue(meshId, { status: ['pending'] as any })) {
+        const al = task.autoLaunch;
+        const sid = al ? readNonEmptyString(al.sessionId) : '';
+        if (!al || (al.status !== 'started' && al.status !== 'completed') || !sid) continue;
+        if (!daemonIdsEquivalent(al.nodeId, nodeId)) continue;
+        const launchedAtMs = Date.parse(al.updatedAt);
+        const inBaseWindow = Number.isFinite(launchedAtMs) && nowMs - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS;
+        const inBackoff = autoLaunchAwaitClaimBackoff.has(`${meshId}::${task.id}`);
+        if (inBaseWindow || inBackoff) out.push(sid);
+    }
+    return out;
+}
+
 // De-dup for repeated `skipped` ledger noise: the reconcile loop re-runs the queue
 // trigger every 4s, so a task that can't be claimed (e.g. a remote node with no
 // transport, or a node under cooldown) would otherwise append an identical
@@ -1110,8 +1184,46 @@ export function isSessionActivelyGenerating(components: DaemonComponents, sessio
     return sessionStateLooksActive(state);
 }
 
+/**
+ * RECLAIM-FALSEPOS tri-state busy verdict for a session id.
+ *
+ * The binary isSessionActivelyGenerating() folds "absence of a positive generating
+ * signal" into a definitive NEGATIVE (returns false when the instance is absent). But a
+ * REMOTE session (never in THIS daemon's instanceManager) — or a locally-present session
+ * looked up under a skewed id form — then looks "not generating" and can be reclaimed out
+ * from under a worker that is genuinely mid-turn. This resolves an explicit three-way
+ * verdict instead:
+ *   - GENERATING       — a locally-present instance reports an active/streaming state.
+ *   - IDLE_CONFIRMED    — a locally-present instance reports a non-active (idle/terminal)
+ *                         state. Positive local evidence the worker is not working.
+ *   - UNKNOWN           — no locally-present instance matches (remote / gone / id-skew) or
+ *                         the observation failed. NEVER treated as IDLE_CONFIRMED.
+ *
+ * The lookup scans getByCategory('cli') with sessionIdsEquivalent (the same equivalence
+ * matching nodeHasActiveMeshWork / liveSessionCountForNode use) rather than a raw
+ * instanceManager.getInstance(id) Map.get, so an id-form-skewed but present session is
+ * found (closing the same id-form-skew hole class e245c2f9's F1 fixed elsewhere).
+ */
+export type SessionBusyVerdict = 'GENERATING' | 'IDLE_CONFIRMED' | 'UNKNOWN';
+export function resolveSessionBusyVerdict(components: DaemonComponents, sessionId: string): SessionBusyVerdict {
+    if (!sessionId) return 'UNKNOWN';
+    try {
+        const instances = components.instanceManager?.getByCategory?.('cli') || [];
+        const inst = instances.find((i: any) => {
+            const sid = readNonEmptyString(i?.getState?.().instanceId);
+            return sid && sessionIdsEquivalent(sid, sessionId);
+        });
+        if (!inst) return 'UNKNOWN'; // remote / gone / id-form skew not present locally
+        const state = inst.getState?.();
+        if (!state) return 'UNKNOWN';
+        return sessionStateLooksActive(state) ? 'GENERATING' : 'IDLE_CONFIRMED';
+    } catch {
+        return 'UNKNOWN'; // failed observation ⇒ unknown, never a definitive idle
+    }
+}
+
 function liveSessionCountForNode(components: DaemonComponents, meshId: string, nodeId: string): number {
-    return components.instanceManager.getByCategory('cli').filter((inst: any) => {
+    const localInstances = components.instanceManager.getByCategory('cli').filter((inst: any) => {
         const state = inst.getState();
         const settings = state.settings as Record<string, unknown> || {};
         if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
@@ -1122,7 +1234,20 @@ function liveSessionCountForNode(components: DaemonComponents, meshId: string, n
         if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
         const status = readNonEmptyString(state.status).toLowerCase();
         return !isTerminalSessionStatus(status);
-    }).length;
+    });
+    let count = localInstances.length;
+    // (A) AUTOLAUNCH-CLAIM-CHURN: also count launched-but-not-yet-claimed sessions targeting this
+    // node whose await-claim window is still open. A REMOTE such session is invisible to the local
+    // instanceManager above, so without this the maxConcurrentSessions cap undercounts it and a
+    // duplicate ghost launch slips through. Exclude any id already represented by a local instance
+    // so a co-located launch is not double-counted.
+    const localSessionIds = localInstances
+        .map((inst: any) => readNonEmptyString(inst.getState().instanceId))
+        .filter(Boolean);
+    for (const sid of inWindowAutoLaunchSessionIdsForNode(meshId, nodeId)) {
+        if (!localSessionIds.some(local => sessionIdsEquivalent(local, sid))) count += 1;
+    }
+    return count;
 }
 
 /**
@@ -1141,6 +1266,12 @@ function liveSessionCountForNode(components: DaemonComponents, meshId: string, n
  * not match, preserving the legitimate first-session spawn.
  */
 function nodeHasLiveSessionPendingClaim(components: DaemonComponents, meshId: string, nodeId: string): boolean {
+    // (A) AUTOLAUNCH-CLAIM-CHURN remote-awareness: a task whose auto-launch record targets this
+    // node and is still inside its await-claim window (base or backoff) already has a session on
+    // its way to claim — even when that session is REMOTE and thus invisible to the local
+    // instanceManager scan below. Treat it as a live pending-claim session so a duplicate launch
+    // is suppressed and no ghost accumulates every ~90s.
+    if (inWindowAutoLaunchSessionIdsForNode(meshId, nodeId).length > 0) return true;
     // Session ids currently holding an assigned queue task on this node — those are busy,
     // not pending claimers, so they must NOT suppress a (read-only) launch.
     const busySessionIds = new Set(
@@ -1312,6 +1443,69 @@ function readMeshNodeId(node: any): string {
     return normalizeMeshNodeId(node) ?? '';
 }
 
+// AUTOLAUNCH-CLAIM-CHURN. The await-claim window for a launched (remote) session has expired
+// without a claim. Instead of a blind respawn, re-drive the claim for the EXISTING session,
+// backing off when its liveness is unknown, and only respawning when it is provably unclaimable.
+// Returns a directive for the caller:
+//   - 'claimed'  — the re-drive claimed/dispatched the task into the existing session (progress).
+//   - 'fallback' — the post-cap direct dispatch delivered the task into the existing session.
+//   - 'backoff'  — liveness unknown; the window was extended (or is still cooling down). No launch.
+//   - 'respawn'  — the session is provably gone/unclaimable; the caller may launch a fresh one.
+function driveExpiredAwaitClaim(
+    components: DaemonComponents,
+    meshId: string,
+    task: MeshWorkQueueEntry,
+    ctx: { sessionId: string; nodeId: string; providerType: string },
+): 'claimed' | 'fallback' | 'backoff' | 'respawn' {
+    const { sessionId, nodeId, providerType } = ctx;
+    const backoffKey = `${meshId}::${task.id}`;
+    const nowMs = Date.now();
+    const state = autoLaunchAwaitClaimBackoff.get(backoffKey) || { cycles: 0, nextAttemptAtMs: 0 };
+    // Rate-limit re-drive attempts to the backoff cadence so the 4s reconcile tick does not hammer
+    // a still-cooling-down window. The initial (no-state) expiry proceeds immediately.
+    if (state.nextAttemptAtMs && nowMs < state.nextAttemptAtMs) return 'backoff';
+
+    const atCap = state.cycles >= AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES;
+    const live = remoteSessionAppearsLive(meshId, sessionId);
+
+    // (B) Re-drive when the remote view shows the session live; (C) after the backoff cap, force the
+    // same direct dispatch unconditionally. Both funnel through tryAssignQueueTask, which
+    // idempotently (re)registers the session, delivers the task message (send_chat), and marks the
+    // row assigned — the exact operation a coordinator performs manually via mesh_send_task. (D)
+    // The setRemoteIdleSession re-register makes this robust to a dropped agent:ready.
+    if ((live || atCap) && nodeId && providerType) {
+        try {
+            MeshRuntimeStore.getInstance().setRemoteIdleSession(meshId, nodeId, sessionId, providerType, nowMs + AUTO_LAUNCH_REMOTE_IDLE_TTL_MS);
+        } catch { /* best-effort re-register */ }
+        const assigned = tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType);
+        if (assigned) {
+            autoLaunchAwaitClaimBackoff.delete(backoffKey);
+            const isFallback = atCap && !live;
+            recordAutoLaunchEvent(meshId, {
+                phase: 'completed',
+                taskId: task.id,
+                reason: isFallback ? 'await_claim_direct_dispatch_fallback' : 'await_claim_redriven',
+                nodeId,
+                sessionId,
+            });
+            // Content-free progress line (ids only).
+            LOG.info('MeshQueue', `Auto-launch await-claim ${isFallback ? 'direct-dispatch fallback' : 're-drive'} claimed task ${task.id} into existing session ${sessionId} on node ${nodeId} (mesh ${meshId})`);
+            return isFallback ? 'fallback' : 'claimed';
+        }
+        if (atCap) {
+            // The forced dispatch could not claim — the session is genuinely gone/unclaimable.
+            // Authorize a fresh respawn (ghosts were already prevented through the backoff window).
+            autoLaunchAwaitClaimBackoff.delete(backoffKey);
+            return 'respawn';
+        }
+    }
+    // Liveness unknown (or live-but-not-claimable) and not at cap → extend the window with backoff.
+    const cycles = Math.min(state.cycles + 1, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES);
+    autoLaunchAwaitClaimBackoff.set(backoffKey, { cycles, nextAttemptAtMs: nowMs + awaitClaimWindowMs(cycles) });
+    recordAutoLaunchEvent(meshId, { phase: 'skipped', taskId: task.id, reason: 'awaiting_launched_session_claim_backoff', nodeId, sessionId });
+    return 'backoff';
+}
+
 async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, meshId: string, mesh: any): Promise<boolean> {
     const queue = getQueue(meshId);
     // DEPENDSON-GATE-SYMMETRY: status index over the FULL queue (incl. completed)
@@ -1319,6 +1513,15 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
     // dependency, not just the still-active rows.
     const statusById = new Map(queue.map(task => [task.id, task.status] as const));
     const pending = queue.filter(task => task.status === 'pending');
+    // AUTOLAUNCH-CLAIM-CHURN: prune await-claim backoff state for tasks of this mesh that are no
+    // longer pending (claimed/completed/cancelled) so the map cannot grow without bound.
+    {
+        const pendingIds = new Set(pending.map(t => t.id));
+        const prefix = `${meshId}::`;
+        for (const key of [...autoLaunchAwaitClaimBackoff.keys()]) {
+            if (key.startsWith(prefix) && !pendingIds.has(key.slice(prefix.length))) autoLaunchAwaitClaimBackoff.delete(key);
+        }
+    }
     if (!pending.length) return false;
 
     // Write cap + read-only cap resolved through the shared helpers from the
@@ -1367,14 +1570,28 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
         // session never reaches idle within the window, a later tick retries.
         if (task.autoLaunch?.status === 'completed' && task.autoLaunch.sessionId) {
             const launchedAtMs = Date.parse(task.autoLaunch.updatedAt);
+            const alSessionId = readNonEmptyString(task.autoLaunch.sessionId);
+            const alNodeId = readNonEmptyString(task.autoLaunch.nodeId);
+            const alProvider = readNonEmptyString(task.autoLaunch.providerType);
             if (Number.isFinite(launchedAtMs) && Date.now() - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS) {
                 // Record the skip in the ledger ONLY (dedup'd). Do NOT call markAutoLaunch
                 // here: recordTaskAutoLaunch overwrites task.autoLaunch wholesale, which would
                 // erase the very `completed` record (status + sessionId + updatedAt) this guard
                 // reads on the next tick, reopening the duplicate-launch hole it closes.
-                recordAutoLaunchEvent(meshId, { phase: 'skipped', taskId: task.id, reason: 'awaiting_launched_session_claim', nodeId: task.autoLaunch.nodeId, sessionId: task.autoLaunch.sessionId });
+                recordAutoLaunchEvent(meshId, { phase: 'skipped', taskId: task.id, reason: 'awaiting_launched_session_claim', nodeId: alNodeId, sessionId: alSessionId });
                 continue;
             }
+            // AUTOLAUNCH-CLAIM-CHURN: the initial await-claim window expired. Rather than a blind
+            // respawn (which the local-only respawn guards can't dedup for a remote pending-claim
+            // session → ghost accumulation), re-drive the claim for the EXISTING launched session,
+            // backing off on unknown liveness and direct-dispatching after the cap. Only a
+            // 'respawn' directive falls through to a fresh launch below.
+            if (Number.isFinite(launchedAtMs) && alSessionId && alNodeId) {
+                const outcome = driveExpiredAwaitClaim(components, meshId, task, { sessionId: alSessionId, nodeId: alNodeId, providerType: alProvider });
+                if (outcome === 'claimed' || outcome === 'fallback') return true; // progress; suppress a duplicate launch
+                if (outcome === 'backoff') continue;                              // window extended; no respawn
+                // outcome === 'respawn' → session provably gone; proceed to a fresh launch below.
+            }
         }
 
         const candidateNodes = Array.isArray(mesh?.nodes)