@adhdev/daemon-core 1.0.21-rc.4 → 1.0.21-rc.5

package/dist/mesh/mesh-completion-synthesis.d.ts

@@ -2,6 +2,15 @@ import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
 import type { LocalMeshEntry } from '../repo-mesh-types.js';
 export declare function reconcileUnterminatedDirectDispatches(components: DaemonComponents, mesh: LocalMeshEntry, selfIds: string[], localDaemonId: string | undefined): Promise<void>;
 export declare function autoPruneStaleDirectDispatches(components: DaemonComponents, mesh: LocalMeshEntry, selfIds: string[], localDaemonId: string | undefined, minAgeMs: number): Promise<void>;
+export interface AssignedTaskTerminalEvidence {
+    outcome: 'completed';
+    finalSummary: string;
+    transcriptMessageAt?: string;
+    providerSessionId?: string;
+    providerType?: string;
+    nodeId?: string;
+    sessionId: string;
+}
 export declare function pollAssignedTaskTerminalEvidence(components: DaemonComponents, mesh: {
     id: string;
     nodes?: Array<{
@@ -15,4 +24,4 @@ export declare function pollAssignedTaskTerminalEvidence(components: DaemonCompo
     assignedNodeId?: string;
     assignedProviderType?: string;
     dispatchTimestamp?: string;
-}): Promise<'completed' | null>;
+}): Promise<AssignedTaskTerminalEvidence | null>;

package/dist/mesh/mesh-events-stale.d.ts

@@ -43,6 +43,27 @@ export declare function reconcileDirectDispatchCompletionFromTranscript(args: {
      * ledger entry below; absent on legacy rows → daemon-level routing (unchanged).
      */
     targetCoordinatorSessionId?: string;
+    /**
+     * WATCHDOG-FINALSUMMARY-LOST: fallback dispatch anchor for a CLAIM-PATH row that has no
+     * `task_dispatched` direct-dispatch ledger entry (findDirectDispatchLedgerEntry → null). The
+     * assigned-stranded watchdog already PROVED the transcript is idle-with-final-assistant AND
+     * dated at/after this timestamp before calling; supplying it dates the completion for the
+     * ledger/diagnostics. Direct-dispatch callers omit it → the ledger entry's timestamp is used
+     * (unchanged).
+     */
+    dispatchTimestamp?: string;
+    /**
+     * WATCHDOG-FINALSUMMARY-LOST: the caller (the assigned-stranded watchdog poll,
+     * pollAssignedTaskTerminalEvidence) has ALREADY enforced the turn-end proof this function's
+     * grace + transcript_not_proven gates exist for — a settled-idle read, a final assistant dated
+     * at/after dispatch, no trailing tool activity, and a continuous-idle streak. Those gates guard
+     * the direct-dispatch first-idle-tick synth that fires ~1s after dispatch off a possibly-stale
+     * tail; the watchdog does not fire until that proof holds, so re-applying the (60s/120s) grace
+     * here would only DELAY a completion the watchdog already validated. When set, skip the grace +
+     * transcript_not_proven gates (the terminal-ledger dedup + weak-supersession backstops remain).
+     * Direct-dispatch callers omit it → the gates apply exactly as before (no regression).
+     */
+    preValidatedTranscriptEvidence?: boolean;
     source?: string;
 }): {
     reconciled: boolean;

package/dist/providers/spec/fsm-types.d.ts

@@ -181,6 +181,9 @@ export interface CliSpecV4 {
     delegate?: DelegateTrigger[];
     native_history?: NativeHistoryConfig;
     requiresFinalAssistantBeforeIdle?: boolean;
+    /** Completion-timing HOLD class (native-history provider whose answer lands in native history, e.g.
+     *  antigravity-cli): idle-without-final-assistant holds for the transcript instead of emitting/flooring. */
+    holdCompletionForTranscript?: boolean;
 }
 export declare function isV4Spec(raw: unknown): raw is CliSpecV4;
 export declare function initialState(spec: CliSpecV4): FsmState;

package/package.json

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

package/src/cli-adapters/provider-cli-shared.ts

@@ -215,8 +215,18 @@ export interface CliProviderModule {
     requirePromptEchoBeforeSubmit?: boolean;
     /** Allow sending another prompt while the CLI is still generating so users can intervene mid-turn. */
     allowInputDuringGeneration?: boolean;
-    /** When true, only transition to idle after the parsed transcript includes a final standard assistant message. */
+    /** When true, only transition to idle after the parsed transcript includes a final standard assistant message.
+     *  Also selects the completion-timing FLOOR (mid-tool-valley-prone native source, e.g. codex/kimi/cursor/opencode):
+     *  an idle-without-final-assistant holds the decoupled CANON-C completion under the min-elapsed floor. False = a
+     *  write-lag native source (e.g. claude-cli) that emits immediately. See holdCompletionForTranscript for the
+     *  third (hold) class. */
     requiresFinalAssistantBeforeIdle?: boolean;
+    /** Completion-timing HOLD class (e.g. antigravity-cli): a native-history provider whose live idle verdict is
+     *  PTY-derived but whose authoritative answer lands in native history. When true, an idle-without-final-assistant
+     *  HOLDS for the transcript to land (holdForTranscript) instead of emitting/flooring, and keeps holding past the
+     *  30s finalization cap while the PTY is still active (bounded by the hard cap). The third completion-timing class
+     *  alongside immediate (requiresFinalAssistantBeforeIdle=false) and floor (requiresFinalAssistantBeforeIdle=true). */
+    holdCompletionForTranscript?: boolean;
     /** When true, allow providers to augment stale snapshot data before parse. Reserved for future use. */
     augmentStaleSnapshot?: boolean;
     /** When provider-owned, daemon treats provider parser output as canonical transcript authority. */

package/src/mesh/mesh-completion-synthesis.ts

@@ -432,11 +432,28 @@ export async function autoPruneStaleDirectDispatches(
 // Conservative: a non-idle read, a read failure, no final summary, or a summary provably BEFORE
 // dispatch all yield null (fall through to the caller's normal reclaim decision) — the poll can
 // only PREVENT a wrong re-drive, never invent a completion.
+//
+// WATCHDOG-FINALSUMMARY-LOST: the poll now returns the FINAL ASSISTANT SUMMARY it read (not just
+// the 'completed' verdict) so the watchdog caller can propagate a finalSummary-bearing completion
+// to the coordinator (the SAME [System] notification a native generating_completed produces),
+// instead of dropping the summary and only flipping the row + tracing a structural DROP. The
+// evidence carried here is exactly what reconcileDirectDispatchCompletionFromTranscript needs to
+// build and queue that completion.
+export interface AssignedTaskTerminalEvidence {
+    outcome: 'completed';
+    finalSummary: string;
+    transcriptMessageAt?: string;
+    providerSessionId?: string;
+    providerType?: string;
+    nodeId?: string;
+    sessionId: string;
+}
+
 export async function pollAssignedTaskTerminalEvidence(
     components: DaemonComponents,
     mesh: { id: string; nodes?: Array<{ id: string; daemonId?: string; workspace?: string }> },
     row: { id: string; assignedSessionId?: string; assignedNodeId?: string; assignedProviderType?: string; dispatchTimestamp?: string },
-): Promise<'completed' | null> {
+): Promise<AssignedTaskTerminalEvidence | null> {
     const sessionId = readNonEmptyString(row.assignedSessionId);
     const nodeId = readNonEmptyString(row.assignedNodeId);
     if (!sessionId || !nodeId) return null; // no worker to read
@@ -508,5 +525,17 @@ export async function pollAssignedTaskTerminalEvidence(
     // cannot distinguish a self-reported failure from the plain transcript tail here (that lives
     // in buildTaskCompletionEvidence's structured-result path), and the alternative — re-driving a
     // finished worker — is strictly worse, so a proven turn-end short-circuits to 'completed'.
-    return 'completed';
+    //
+    // WATCHDOG-FINALSUMMARY-LOST: carry the read evidence back to the caller so it can propagate a
+    // finalSummary-bearing completion (not just flip the row). providerSessionId is best-effort from
+    // the read payload — absent → daemon-level routing (unchanged from the reconcile paths).
+    return {
+        outcome: 'completed',
+        finalSummary: evidence.finalSummary,
+        ...(evidence.transcriptMessageAt ? { transcriptMessageAt: evidence.transcriptMessageAt } : {}),
+        ...(readNonEmptyString(payload.providerSessionId) ? { providerSessionId: readNonEmptyString(payload.providerSessionId) } : {}),
+        ...(providerType ? { providerType } : {}),
+        ...(nodeId ? { nodeId } : {}),
+        sessionId,
+    };
 }

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

@@ -208,6 +208,27 @@ export function reconcileDirectDispatchCompletionFromTranscript(args: {
      * ledger entry below; absent on legacy rows → daemon-level routing (unchanged).
      */
     targetCoordinatorSessionId?: string;
+    /**
+     * WATCHDOG-FINALSUMMARY-LOST: fallback dispatch anchor for a CLAIM-PATH row that has no
+     * `task_dispatched` direct-dispatch ledger entry (findDirectDispatchLedgerEntry → null). The
+     * assigned-stranded watchdog already PROVED the transcript is idle-with-final-assistant AND
+     * dated at/after this timestamp before calling; supplying it dates the completion for the
+     * ledger/diagnostics. Direct-dispatch callers omit it → the ledger entry's timestamp is used
+     * (unchanged).
+     */
+    dispatchTimestamp?: string;
+    /**
+     * WATCHDOG-FINALSUMMARY-LOST: the caller (the assigned-stranded watchdog poll,
+     * pollAssignedTaskTerminalEvidence) has ALREADY enforced the turn-end proof this function's
+     * grace + transcript_not_proven gates exist for — a settled-idle read, a final assistant dated
+     * at/after dispatch, no trailing tool activity, and a continuous-idle streak. Those gates guard
+     * the direct-dispatch first-idle-tick synth that fires ~1s after dispatch off a possibly-stale
+     * tail; the watchdog does not fire until that proof holds, so re-applying the (60s/120s) grace
+     * here would only DELAY a completion the watchdog already validated. When set, skip the grace +
+     * transcript_not_proven gates (the terminal-ledger dedup + weak-supersession backstops remain).
+     * Direct-dispatch callers omit it → the gates apply exactly as before (no regression).
+     */
+    preValidatedTranscriptEvidence?: boolean;
     source?: string;
 }): { reconciled: boolean; kind?: MeshLedgerKind; alreadyTerminal?: boolean; workerResult?: unknown; ledgerEntryId?: string; reason?: string } {
     const finalSummary = readNonEmptyString(args.finalSummary);
@@ -251,10 +272,14 @@ export function reconcileDirectDispatchCompletionFromTranscript(args: {
     // `…::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;
+    // WATCHDOG-FINALSUMMARY-LOST: prefer the ledger dispatch timestamp; fall back to the caller's
+    // proven anchor (a claim-path row has no task_dispatched ledger entry to date).
+    const dispatchTime = dispatch?.timestamp
+        ? new Date(dispatch.timestamp).getTime()
+        : (args.dispatchTimestamp ? new Date(args.dispatchTimestamp).getTime() : Number.NaN);
     const transcriptTime = args.transcriptMessageAt ? new Date(args.transcriptMessageAt).getTime() : Number.NaN;
     const transcriptAfterDispatch = Number.isFinite(dispatchTime) && Number.isFinite(transcriptTime) && transcriptTime >= dispatchTime;
-    if (workerResult.source !== 'final_summary_json' && !transcriptAfterDispatch) {
+    if (!args.preValidatedTranscriptEvidence && workerResult.source !== 'final_summary_json' && !transcriptAfterDispatch) {
         return { reconciled: false, reason: 'transcript_not_proven_after_dispatch' };
     }
     // NOTIF-MISS grace gate (FIX 1): refuse to synthesize a completion for a direct dispatch
@@ -271,7 +296,7 @@ export function reconcileDirectDispatchCompletionFromTranscript(args: {
     // so it is exempt; the grace only guards the ambiguous plain-text-tail case. When the dispatch
     // entry is missing we cannot date it and do NOT block (the stale-summary timestamp guard +
     // FIX 2 supersession remain the correctness backstops).
-    if (Number.isFinite(dispatchTime) && workerResult.source !== 'final_summary_json') {
+    if (!args.preValidatedTranscriptEvidence && Number.isFinite(dispatchTime) && workerResult.source !== 'final_summary_json') {
         const dispatchedToIdleSession = dispatch?.payload?.dispatchedToIdleSession === true;
         const graceMs = dispatchedToIdleSession
             ? DIRECT_DISPATCH_IDLE_SESSION_RECONCILE_GRACE_MS

package/src/mesh/mesh-reconcile-loop.ts

@@ -64,7 +64,7 @@ import { getQueue, reclaimStrandedAssignedTask, updateTaskStatus } from './mesh-
 import { resolveSessionBusyVerdict, runContinuousAutoFastForwardScan, runPendingCoordinatorCatchupScan } from './mesh-queue-assignment.js';
 import { readLedgerEntries } from './mesh-ledger.js';
 import type { MeshLedgerEntry } from './mesh-ledger.js';
-import { findTerminalLedgerEvidenceForTask } from './mesh-events-stale.js';
+import { findTerminalLedgerEvidenceForTask, reconcileDirectDispatchCompletionFromTranscript } from './mesh-events-stale.js';
 import {
     resolveCoordinatorDaemonIds,
     daemonHostsMesh,
@@ -84,6 +84,7 @@ import {
     reconcileUnterminatedDirectDispatches,
     autoPruneStaleDirectDispatches,
     pollAssignedTaskTerminalEvidence,
+    type AssignedTaskTerminalEvidence,
 } from './mesh-completion-synthesis.js';
 import { sessionStatusFromNodes } from './mesh-active-work.js';
 
@@ -941,6 +942,60 @@ async function evaluateEarlyIdleTranscriptArm(
     return verdict === 'UNKNOWN';             // remote, unknowable class — trust the (a) reprobe
 }
 
+// WATCHDOG-FINALSUMMARY-LOST. When the assigned-stranded watchdog / delivered-no-turn deadline
+// proves a task terminal from the worker transcript (pollAssignedTaskTerminalEvidence), it must
+// PROPAGATE that completion to the coordinator the SAME way a native agent:generating_completed
+// does — a finalSummary-bearing [System] notification — not merely flip the queue row and trace a
+// structural DROP. A provider that finishes early (e.g. codex ~25s) is watchdog-completed here; if
+// the summary is dropped the coordinator NEVER learns what the worker produced (kimi only got it by
+// the lucky timing of the 180s stall-reconcile's second emit).
+//
+// reconcileDirectDispatchCompletionFromTranscript is the shared native-completion synth: it writes
+// the terminal ledger WITH the finalSummary and queues the coordinator event with the same
+// buildMeshSystemMessage the native path uses. It is idempotent — hasTerminalLedgerAfterDispatch
+// makes a second call (or a later real emit) a no-op (alreadyTerminal), and its non-self-attributing
+// synth is marked WEAK so the worker's own later emit can still supersede it rather than being
+// dropped as a duplicate. That is the dedup guarantee: at most one [System] completion surfaces.
+//
+// Returns true if a terminal ledger for this task now exists (freshly written OR already present) —
+// the caller then skips its own bare-payload ledger write, which lacked the finalSummary entirely.
+function propagateWatchdogTranscriptCompletion(
+    meshId: string,
+    row: { id: string; assignedNodeId?: string; assignedSessionId?: string; assignedProviderType?: string; dispatchTimestamp?: string },
+    evidence: AssignedTaskTerminalEvidence,
+    source: string,
+): boolean {
+    const sessionId = readNonEmptyString(row.assignedSessionId) || evidence.sessionId;
+    if (!sessionId || !readNonEmptyString(evidence.finalSummary)) {
+        // No routable session or no summary to carry — fall back to the caller's bare ledger write.
+        return false;
+    }
+    try {
+        const result = reconcileDirectDispatchCompletionFromTranscript({
+            meshId,
+            nodeId: readNonEmptyString(row.assignedNodeId) || evidence.nodeId,
+            sessionId,
+            providerType: readNonEmptyString(row.assignedProviderType) || evidence.providerType,
+            providerSessionId: evidence.providerSessionId,
+            taskId: row.id,
+            finalSummary: evidence.finalSummary,
+            ...(evidence.transcriptMessageAt ? { transcriptMessageAt: evidence.transcriptMessageAt } : {}),
+            ...(readNonEmptyString(row.dispatchTimestamp) ? { dispatchTimestamp: readNonEmptyString(row.dispatchTimestamp) } : {}),
+            // The watchdog poll already enforced idle + post-dispatch + no-trailing-tool + streak;
+            // skip the reconcile's own grace/transcript_not_proven gates (dedup backstops remain).
+            preValidatedTranscriptEvidence: true,
+            source,
+        });
+        // reconciled → freshly queued the coordinator completion; alreadyTerminal → a terminal
+        // ledger (a real emit that raced in, or a prior watchdog synth) is already present. Either
+        // way a finalSummary-bearing completion has been (or will be) delivered; the caller must NOT
+        // add its summary-less ledger row on top.
+        return result.reconciled || result.alreadyTerminal === true;
+    } catch {
+        return false; // best-effort — fall back to the caller's bare ledger write
+    }
+}
+
 // PHASE 2.5 — assigned-stranded dispatch watchdog (Bug B). claimNextTask atomically
 // flips a row to 'assigned' BEFORE the fire-and-forget dispatch runs. If that dispatch
 // neither rejects (→ no .catch requeue) nor is confirmed delivered — a relay that hangs
@@ -1013,11 +1068,19 @@ async function recoverStrandedAssignedDispatches(
                 const terminalEvidence = await pollAssignedTaskTerminalEvidence(components, mesh, row);
                 if (terminalEvidence) {
                     assignedIdleFinalAssistantSince.delete(idleTranscriptStreakKey);
-                    updateTaskStatus(meshId, row.id, terminalEvidence);
-                    if (!findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id })) {
+                    updateTaskStatus(meshId, row.id, terminalEvidence.outcome);
+                    // WATCHDOG-FINALSUMMARY-LOST: propagate the completion to the coordinator WITH the
+                    // finalSummary the poll read — the SAME [System] notification the native
+                    // generating_completed produces — instead of only tracing a structural DROP. When
+                    // propagation delivered (or a terminal ledger already exists), skip the bare
+                    // summary-less ledger write below; only fall back to it if propagation could not run.
+                    const propagated = propagateWatchdogTranscriptCompletion(
+                        meshId, row, terminalEvidence, 'early_idle_transcript_evidence',
+                    );
+                    if (!propagated && !findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id })) {
                         try {
                             appendLedgerEntry(meshId, {
-                                kind: terminalEvidence === 'completed' ? 'task_completed' : 'task_failed',
+                                kind: terminalEvidence.outcome === 'completed' ? 'task_completed' : 'task_failed',
                                 nodeId: row.assignedNodeId,
                                 sessionId: row.assignedSessionId,
                                 providerType: row.assignedProviderType,
@@ -1032,14 +1095,15 @@ async function recoverStrandedAssignedDispatches(
                     LOG.warn('MeshReconcile', `Early-completed assigned task ${row.id} on mesh ${meshId} `
                         + `(node=${row.assignedNodeId ?? '?'} session=${row.assignedSessionId ?? '?'}): worker idle with a `
                         + `final assistant message after dispatch for ≥${Math.round(ASSIGNED_IDLE_TRANSCRIPT_COMPLETE_MS / 1000)}s — `
-                        + `the completion event was lost/late (pure-PTY provider), task is ${terminalEvidence} without waiting the 15-min deadline`);
-                    traceMeshEventDrop('assigned_early_transcript_completed', {
+                        + `the completion event was lost/late (pure-PTY provider), task is ${terminalEvidence.outcome} without waiting the 15-min deadline`
+                        + `${propagated ? ' (finalSummary propagated to coordinator)' : ''}`);
+                    traceMeshEventStage('assigned_early_transcript_completed', {
                         taskId: row.id,
                         sessionId: row.assignedSessionId,
                         nodeId: row.assignedNodeId,
                         meshId,
                         event: 'agent:generating_completed',
-                    }, terminalEvidence);
+                    }, propagated ? 'propagated' : terminalEvidence.outcome);
                     continue;
                 }
                 // Poll was inconclusive (mid-turn re-check / stale tail / unreadable) — reset the
@@ -1290,11 +1354,17 @@ async function recoverStrandedAssignedDispatches(
                 deliveredNoTurnUnknownStreak.delete(streakKey);
                 // updateTaskStatus ends the single-flight dispatch window on any transition off
                 // 'assigned', so a later requeue/re-dispatch is never blocked by a stale mark.
-                updateTaskStatus(meshId, row.id, terminalEvidence);
-                if (!findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id })) {
+                updateTaskStatus(meshId, row.id, terminalEvidence.outcome);
+                // WATCHDOG-FINALSUMMARY-LOST: propagate the finalSummary-bearing completion to the
+                // coordinator (same [System] notification as the native path); only fall back to the
+                // bare summary-less ledger write when propagation could not run.
+                const propagated = propagateWatchdogTranscriptCompletion(
+                    meshId, row, terminalEvidence, 'redrive_deadline_transcript_evidence',
+                );
+                if (!propagated && !findTerminalLedgerEvidenceForTask({ meshId, taskId: row.id })) {
                     try {
                         appendLedgerEntry(meshId, {
-                            kind: terminalEvidence === 'completed' ? 'task_completed' : 'task_failed',
+                            kind: terminalEvidence.outcome === 'completed' ? 'task_completed' : 'task_failed',
                             nodeId: row.assignedNodeId,
                             sessionId: row.assignedSessionId,
                             providerType: row.assignedProviderType,
@@ -1308,14 +1378,15 @@ async function recoverStrandedAssignedDispatches(
                 }
                 LOG.warn('MeshReconcile', `Skipped delivered-no-turn re-drive for task ${row.id} on mesh ${meshId} `
                     + `(node=${row.assignedNodeId ?? '?'} session=${row.assignedSessionId ?? '?'}): worker transcript is idle with a `
-                    + `final assistant message after dispatch — the completion event was lost/late, task is ${terminalEvidence}, NOT re-driving`);
-                traceMeshEventDrop('redrive_deadline_transcript_completed', {
+                    + `final assistant message after dispatch — the completion event was lost/late, task is ${terminalEvidence.outcome}, NOT re-driving`
+                    + `${propagated ? ' (finalSummary propagated to coordinator)' : ''}`);
+                traceMeshEventStage('redrive_deadline_transcript_completed', {
                     taskId: row.id,
                     sessionId: row.assignedSessionId,
                     nodeId: row.assignedNodeId,
                     meshId,
                     event: 'agent:generating_completed',
-                }, `${reclaimReason} → transcript ${terminalEvidence}`);
+                }, `${reclaimReason} → transcript ${terminalEvidence.outcome}${propagated ? ' propagated' : ''}`);
                 continue;
             }
             const reclaimedLost = reclaimStrandedAssignedTask(meshId, row.id, {

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

@@ -2086,7 +2086,13 @@ export class CliProviderInstance implements ProviderInstance {
                     // eventually emits" fix while filtering the mid-turn false-idle. Scoped to
                     // autonomous mesh sessions (allowMissingAssistantTimeout) so an interactive
                     // antigravity session, which has no coordinator to misfire at, is untouched.
-                    if (this.type === 'antigravity-cli') {
+                    //
+                    // SPEC-DRIVEN completion timing (mission f2f6da1b root 2): the HOLD class is the
+                    // manifest flag `holdCompletionForTranscript` (antigravity-cli declares it), NOT a
+                    // hardcoded provider name — a native-history provider whose PTY-derived idle can
+                    // precede the authoritative transcript write. write-lag (claude) and floor
+                    // (codex/kimi/…) providers leave it false and fall through to the decision below.
+                    if ((this.provider as any)?.holdCompletionForTranscript === true) {
                         if (allowMissingAssistantTimeout) {
                             return { reason: 'missing_final_assistant', terminal: false, holdForTranscript: true };
                         }
@@ -2135,9 +2141,20 @@ export class CliProviderInstance implements ProviderInstance {
                     //     reaches the floor because the next tool call's idle→busy transition cancels
                     //     the pending.
                     //
-                    // No provider manifest flag distinguishes write-lag from mid-tool-call, so the
-                    // scope is the concrete write-lag provider (claude-cli) vs the rest.
-                    const isWriteLagNativeSource = this.type === 'claude-cli';
+                    // SPEC-DRIVEN completion timing (mission f2f6da1b root 2): the HOLD class already
+                    // returned above (holdCompletionForTranscript). The remaining two classes are the
+                    // manifest flag `requiresFinalAssistantBeforeIdle`:
+                    //   • FLOOR — declared (codex-cli / cursor-cli / kimi / opencode): "an idle without
+                    //     a final assistant reply is NOT a genuine turn-end", exactly the CANON-C
+                    //     min-elapsed floor's precondition, so it gets the floor
+                    //     (noExternalTranscriptSource).
+                    //   • IMMEDIATE (write-lag) — not declared (claude-cli): idle is authoritative, the
+                    //     transcript write merely trails by a fraction of a second, so it emits
+                    //     IMMEDIATELY, un-floored.
+                    // This is the SAME flag the sibling branch below (source !== 'external-native')
+                    // uses for the identical noExternalTranscriptSource decision, so the two branches
+                    // agree; and it covers third-party providers instead of a hardcoded provider name.
+                    const isWriteLagNativeSource = (this.provider as any).requiresFinalAssistantBeforeIdle !== true;
                     return {
                         reason: 'missing_final_assistant',
                         terminal: true,
@@ -3241,9 +3258,11 @@ export class CliProviderInstance implements ProviderInstance {
             // transcript branch above clears the block for a genuine emit once the answer lands).
             // A genuinely quiescent tool-only turn (no assistant bubble, PTY stable) falls through
             // to the existing weak force-emit; a runaway PTY that never quiets releases at the hard
-            // cap so it cannot wedge forever. Scoped to antigravity holdForTranscript so
-            // claude-cli/codex-cli completion timing is unchanged.
-            if (this.type === 'antigravity-cli'
+            // cap so it cannot wedge forever. SPEC-DRIVEN (mission f2f6da1b root 2): scoped to the
+            // HOLD completion-timing class (`holdCompletionForTranscript`, e.g. antigravity-cli) via
+            // its holdForTranscript block — NOT a hardcoded provider name — so claude-cli/codex-cli
+            // (immediate/floor classes, which never produce a holdForTranscript block) are unchanged.
+            if ((this.provider as any)?.holdCompletionForTranscript === true
                 && block.holdForTranscript === true
                 && waitedMs < ANTIGRAVITY_HOLD_HARD_CAP_MS
                 && this.antigravityHoldPtyStillActive()) {

package/src/providers/provider-schema.ts

@@ -79,6 +79,7 @@ const KNOWN_PROVIDER_FIELDS = new Set<string>([
   'submitStrategy',
   'requirePromptEchoBeforeSubmit',
   'requiresFinalAssistantBeforeIdle',
+  'holdCompletionForTranscript',
   'augmentStaleSnapshot',
   'timeouts',
   'disableUpstream',

package/src/providers/sdk/v1/schemas/cli/provider.schema.json

@@ -201,7 +201,12 @@
     "requiresFinalAssistantBeforeIdle": {
       "type": "boolean",
       "default": false,
-      "description": "When true, daemon defers generating→idle until parseSession includes a final standard assistant message."
+      "description": "When true, daemon defers generating→idle until parseSession includes a final standard assistant message. Also selects the completion-timing floor for a native-source provider: an idle without a final assistant reply is treated as a possible mid-tool-call quiet valley, so the decoupled CANON-C completion is held under the min-elapsed floor (noExternalTranscriptSource) rather than emitted immediately. A provider that leaves this false is a write-lag native source (e.g. claude-cli) whose transcript merely trails the finished idle by a write, so it emits immediately."
+    },
+    "holdCompletionForTranscript": {
+      "type": "boolean",
+      "default": false,
+      "description": "Completion-timing authority for a native-history provider whose live idle verdict is PTY-derived but whose authoritative answer lands in native history (e.g. antigravity-cli). When true, an idle-without-final-assistant HOLDS for the native transcript to land (holdForTranscript) instead of emitting or applying the min-elapsed floor, and the hold persists past the 30s finalization cap while the PTY is still active (bounded by the hard cap). This is the third completion-timing class alongside immediate (requiresFinalAssistantBeforeIdle=false) and floor (requiresFinalAssistantBeforeIdle=true)."
     },
     "augmentStaleSnapshot": {
       "type": "boolean",

package/src/providers/spec/fsm-types.ts

@@ -246,6 +246,9 @@ export interface CliSpecV4 {
     delegate?: DelegateTrigger[];
     native_history?: NativeHistoryConfig;
     requiresFinalAssistantBeforeIdle?: boolean;
+    /** Completion-timing HOLD class (native-history provider whose answer lands in native history, e.g.
+     *  antigravity-cli): idle-without-final-assistant holds for the transcript instead of emitting/flooring. */
+    holdCompletionForTranscript?: boolean;
 }
 
 export function isV4Spec(raw: unknown): raw is CliSpecV4 {