@adhdev/daemon-core 1.0.28-rc.5 → 1.0.28-rc.6

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

@@ -616,6 +616,20 @@ export interface MeshWorkQueueEntry {
      * by counting active assignments grouped by node + provider.
      */
     assignedProviderType?: string;
+    /**
+     * Transcript-authority class of the claiming session's provider, stamped at
+     * claim time (P1 of the transcript-authority unification — root repo
+     * docs/design/2026-07-25-transcript-authority-unification.md). Lets the
+     * COORDINATOR side classify a remote worker (early-arm / redrive gates)
+     * without resolving the provider module locally — the structural fix for
+     * the "remote class unknowable → reprobe-only" blind spot. Absent on rows
+     * claimed by older daemons; consumers must fall back to local resolution.
+     */
+    assignedTranscriptProfile?: {
+        class: 'native-source' | 'pure-pty' | 'daemon-owned';
+        timing: 'hold' | 'floor' | 'immediate';
+        emitsPtyTurnEvents: boolean;
+    };
     /** Human/operator reason for terminal cancellation. */
     cancelReason?: string;
     cancelledAt?: string;
@@ -1165,7 +1179,12 @@ export function claimNextTask(
     nodeId: string,
     sessionId: string,
     capabilityTags?: string[],
-    opts?: { providerType?: string; providerMaxParallel?: number; nodeIsWorktree?: boolean },
+    opts?: {
+        providerType?: string;
+        providerMaxParallel?: number;
+        nodeIsWorktree?: boolean;
+        assignedTranscriptProfile?: MeshWorkQueueEntry['assignedTranscriptProfile'];
+    },
 ): MeshWorkQueueEntry | null {
     return MeshRuntimeStore.getInstance().claimNextQueueTask(meshId, nodeId, sessionId, capabilityTags, opts);
 }

package/src/mesh/node-facts.ts

@@ -0,0 +1,54 @@
+/**
+ * buildLocalNodeFacts — THE single producer of this daemon's MeshNodeFacts
+ * bundle (design: root repo docs/design/2026-07-25-deploy-lag-visibility.md).
+ *
+ * De-mirroring core: the reporter envelope (git-commands handleGitCommand)
+ * and the self/worktree node stamp (mesh-node-identity, whose local probe
+ * bypasses the envelope) BOTH call this one function, so a fact added here
+ * reaches self and remote nodes identically — the field-by-field dual-path
+ * plumbing that produced the mirror-defect class (version chip self-miss,
+ * slot-cap chip remote-miss, dead stale-build badge) cannot recur for bundle
+ * fields.
+ */
+
+import type { MeshNodeFacts } from '@adhdev/mesh-shared';
+import { getDaemonBuildInfo } from '../build-info.js';
+
+export function buildLocalNodeFacts(deps?: {
+    providerVersions?: Record<string, string> | null;
+    machineNickname?: string | null;
+}): MeshNodeFacts {
+    const build = (() => {
+        try {
+            const info = getDaemonBuildInfo();
+            const commit = typeof info.commit === 'string' && info.commit && info.commit !== 'unknown' ? info.commit : undefined;
+            const commitShort = typeof info.commitShort === 'string' && info.commitShort && info.commitShort !== 'unknown' ? info.commitShort : undefined;
+            const version = typeof info.version === 'string' && info.version && info.version !== 'unknown' ? info.version : undefined;
+            const builtAt = typeof info.builtAt === 'string' && info.builtAt ? info.builtAt : undefined;
+            if (!commit && !version) return undefined;
+            return {
+                ...(commit ? { commit } : {}),
+                ...(commitShort ? { commitShort } : {}),
+                ...(version ? { version } : {}),
+                ...(builtAt ? { builtAt } : {}),
+            };
+        } catch {
+            return undefined;
+        }
+    })();
+    const providerVersions = deps?.providerVersions && Object.keys(deps.providerVersions).length > 0
+        ? deps.providerVersions
+        : undefined;
+    const machineNickname = typeof deps?.machineNickname === 'string' && deps.machineNickname.trim()
+        ? deps.machineNickname.trim()
+        : undefined;
+    return {
+        schemaVersion: 1,
+        reportedAt: Date.now(),
+        ...(build ? { daemonBuild: build } : {}),
+        ...(providerVersions ? { providerVersions } : {}),
+        platform: process.platform,
+        arch: process.arch,
+        ...(machineNickname ? { machineNickname } : {}),
+    };
+}

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

@@ -17,7 +17,7 @@ import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import { shortHash } from '../system/hash.js';
 import type { CliProviderModule } from '../cli-adapters/provider-cli-adapter.js';
 import type { MeshSendKeyItem, MeshSendKeyName } from '../cli-adapters/provider-cli-shared.js';
-import { isPurePtyTranscriptProvider } from '../cli-adapters/provider-cli-shared.js';
+import { resolveTranscriptAuthorityProfile } from './transcript-evidence.js';
 import { createCliAdapter } from './spec/route.js';
 import type { PtyRuntimeMetadata, PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import { StatusMonitor } from './status-monitor.js';
@@ -2101,12 +2101,13 @@ export class CliProviderInstance implements ProviderInstance {
                     // autonomous mesh sessions (allowMissingAssistantTimeout) so an interactive
                     // antigravity session, which has no coordinator to misfire at, is untouched.
                     //
-                    // SPEC-DRIVEN completion timing (mission f2f6da1b root 2): the HOLD class is the
-                    // manifest flag `holdCompletionForTranscript` (antigravity-cli declares it), NOT a
+                    // SPEC-DRIVEN completion timing (mission f2f6da1b root 2, P4 profile
+                    // substitution): the HOLD class is the authority profile's timing==='hold'
+                    // (manifest 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) {
+                    // precede the authoritative transcript write. write-lag (claude, 'immediate') and
+                    // floor (codex/kimi/…, 'floor') classes fall through to the decision below.
+                    if (resolveTranscriptAuthorityProfile(this.provider).timing === 'hold') {
                         if (allowMissingAssistantTimeout) {
                             return { reason: 'missing_final_assistant', terminal: false, holdForTranscript: true };
                         }
@@ -2168,7 +2169,7 @@ export class CliProviderInstance implements ProviderInstance {
                     // 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;
+                    const isWriteLagNativeSource = resolveTranscriptAuthorityProfile(this.provider).timing !== 'floor';
                     return {
                         reason: 'missing_final_assistant',
                         terminal: true,
@@ -2176,14 +2177,15 @@ export class CliProviderInstance implements ProviderInstance {
                         ...(isWriteLagNativeSource ? {} : { noExternalTranscriptSource: true }),
                     };
                 }
-                if ((this.provider as any).requiresFinalAssistantBeforeIdle === true) {
+                if (resolveTranscriptAuthorityProfile(this.provider).timing === 'floor') {
                     return { reason: 'missing_final_assistant', terminal: true, allowTimeout: allowMissingAssistantTimeout, noExternalTranscriptSource: true };
                 }
             } else {
-                LOG.debug('CLI', `[${this.type}] missing_final_assistant (not ownsExternal) requiresFinalAssistant=${!!(this.provider as any).requiresFinalAssistantBeforeIdle}`);
+                const notOwnsExternalTiming = resolveTranscriptAuthorityProfile(this.provider).timing;
+                LOG.debug('CLI', `[${this.type}] missing_final_assistant (not ownsExternal) requiresFinalAssistant=${notOwnsExternalTiming === 'floor'}`);
                 return {
                     reason: 'missing_final_assistant',
-                    terminal: (this.provider as any).requiresFinalAssistantBeforeIdle === true,
+                    terminal: notOwnsExternalTiming === 'floor',
                     allowTimeout: allowMissingAssistantTimeout,
                     // PTY-parsed provider (codex-cli): no external transcript trails the idle
                     // transition, so the CANON-C decoupled emit must observe the min-elapsed floor
@@ -2525,30 +2527,18 @@ export class CliProviderInstance implements ProviderInstance {
             }
         }
 
-        // KIMI-PURE-PTY-COMPLETION-EMIT (Fix 3): before firing a false stall, check the
-        // pure-PTY class (no native transcript → nativeSample was null above). A finished
-        // pure-PTY worker sits at a static idle prompt with an in-turn final assistant
-        // message but never emitted generating_completed — the status-agnostic watchdog
-        // would misread that quiet as a wedge. If the PTY transcript proves a finished
-        // turn, emit the missing completion and SUPPRESS the stall (mark the anchor
-        // emitted so this static idle is not re-checked every tick). No-op for
-        // native-source providers and for a genuinely mid-turn / wedged worker with no
-        // final assistant → the real stall fires below unchanged.
-        if (this.tryReconcilePurePtyCompletionForStall(observedStatus)) {
-            this.meshStallEmittedForAnchor = true;
-            return;
-        }
-
-        // KIMI-NATIVE-SOURCE-COMPLETION-EMIT (Fix 3): the pure-PTY check above is a no-op
-        // for a native-source provider (kimi and kin — transcriptAuthority=provider +
-        // nativeHistory). For that class, a finished-but-quiet idle whose transcript has
-        // gone static (sampleNativeTranscriptProgress stopped re-arming) is otherwise
-        // misread as a wedge. Resolve the completion from the authoritative native
-        // transcript; if it proves a finished turn, emit the missing completion and
-        // SUPPRESS the stall. No-op for pure-PTY providers and for a genuinely mid-turn /
-        // wedged native-source worker with no in-turn final assistant → the real stall
-        // fires below unchanged. Mutually exclusive with the pure-PTY path.
-        if (this.tryReconcileNativeSourceCompletionForStall(observedStatus)) {
+        // TRANSCRIPT-COMPLETION-STALL-RESCUE (P2 of the transcript-authority
+        // unification — historically KIMI-PURE-PTY-COMPLETION-EMIT + KIMI-NATIVE-
+        // SOURCE-COMPLETION-EMIT, two class-enumerated copies of the same rescue).
+        // A finished worker whose generating_completed never emitted (idle→idle
+        // collapse) sits at a STATIC idle prompt; the status-agnostic watchdog
+        // would misread that finished-but-quiet state as a wedge and false-fire
+        // monitor:no_progress. If the class-appropriate transcript (PTY parse or
+        // authoritative native history — completionFinalSummary picks) proves a
+        // finished turn, emit the missing completion and SUPPRESS the stall. A
+        // genuinely mid-turn / wedged worker with no in-turn final assistant falls
+        // through and the real stall fires below unchanged.
+        if (this.tryReconcileTranscriptCompletionForStall(observedStatus)) {
             this.meshStallEmittedForAnchor = true;
             return;
         }
@@ -2718,35 +2708,38 @@ export class CliProviderInstance implements ProviderInstance {
     }
 
     /**
-     * KIMI-PURE-PTY-COMPLETION-EMIT (Fix 3): stall-path completion reconcile for the
-     * PURE-PTY transcript class (kimi and kin — no native transcript, no provider
-     * authority; see isPurePtyTranscriptProvider). Such a worker whose
-     * generating_completed never emitted (the onTurnStarted idle→idle collapse Fix 1
-     * fixes at the source) sits at a STATIC idle prompt: its PTY output stops the
-     * instant the answer is rendered, so the status-agnostic no-progress watchdog
-     * (checkMeshWorkerStall) reads the finished-but-quiet session as a stall and would
-     * false-fire monitor:no_progress. The native-transcript reconcile
-     * (sampleNativeTranscriptProgress) does NOT cover this class (no native source →
-     * null sample), so the stall path needs its own guard.
+     * TRANSCRIPT-COMPLETION-STALL-RESCUE (P2 of the transcript-authority
+     * unification — root repo docs/design/2026-07-25-transcript-authority-
+     * unification.md): stall-path completion reconcile for every class whose
+     * turns can finish without a generating_completed emit (idle→idle collapse)
+     * and then sit PTY-quiet at a static idle prompt.
      *
-     * Called from checkMeshWorkerStall just before the fire. Returns true when the
-     * session is a finished pure-PTY turn — idle, no pending response, and a PTY-parsed
-     * in-turn final assistant summary — in which case it emits the missing
-     * generating_completed (idempotent: a real/late emit writes the terminal ledger and
-     * the coordinator's reconcile makes any duplicate a no-op) and the caller SUPPRESSES
-     * the stall. Returns false for every other class/state (native-source provider, a
-     * genuinely mid-turn or wedged worker with no final assistant), so a real stall still
-     * fires unchanged.
+     * Historically this was TWO class-enumerated copies — KIMI-PURE-PTY-
+     * COMPLETION-EMIT (Fix 3) gated on isPurePtyTranscriptProvider, and
+     * KIMI-NATIVE-SOURCE-COMPLETION-EMIT gated on isNativeSourceCanonicalHistory
+     * — whose bodies were identical because completionFinalSummary already picks
+     * the class-appropriate evidence source (authoritative native transcript for
+     * a native-source provider, the PTY parse otherwise). The enumeration itself
+     * was the recurring defect: each new class had to be remembered at this site.
+     * The profile collapses it: any class except daemon-owned is eligible, and
+     * the evidence bar — not the class — decides.
      *
-     * Evidence bar is identical to flushMeshCompletionBeforeCleanup: injected task's turn
-     * genuinely started + an in-turn final assistant summary. Conservative by
-     * construction — no summary ⇒ no proof of completion ⇒ return false and let the real
-     * stall fire.
+     * Called from checkMeshWorkerStall just before the fire. Returns true when
+     * the session is a finished turn — idle, nothing pending, the injected
+     * task's turn genuinely started, and an in-turn final assistant summary —
+     * in which case it emits the missing generating_completed (idempotent: a
+     * real/late emit writes the terminal ledger and the coordinator's reconcile
+     * makes any duplicate a no-op) and the caller SUPPRESSES the stall. Returns
+     * false for a daemon-owned provider and for a genuinely mid-turn / wedged
+     * worker with no in-turn final assistant, so a real stall still fires
+     * unchanged. Evidence bar is identical to flushMeshCompletionBeforeCleanup.
      */
-    private tryReconcilePurePtyCompletionForStall(observedStatus: string): boolean {
-        // Only the pure-PTY class — native-source providers are handled by
-        // sampleNativeTranscriptProgress above.
-        if (!isPurePtyTranscriptProvider(this.provider)) return false;
+    private tryReconcileTranscriptCompletionForStall(observedStatus: string): boolean {
+        // daemon-owned transcripts get real PTY turn events — an idle-quiet
+        // daemon-owned worker with no completion emit is a genuine anomaly the
+        // stall should surface, exactly as before this unification.
+        const profile = resolveTranscriptAuthorityProfile(this.provider);
+        if (profile.class === 'daemon-owned') return false;
         // A finished turn is idle with nothing pending. A generating/waiting session is
         // mid-turn (the real stall path should evaluate it), so never complete it here.
         if (observedStatus !== 'idle') return false;
@@ -2770,6 +2763,10 @@ export class CliProviderInstance implements ProviderInstance {
         try {
             parsedMessages = this.adapter?.getScriptParsedStatus?.()?.messages;
         } catch { parsedMessages = undefined; }
+        // completionFinalSummary turn-scopes the class-appropriate transcript (native
+        // history for a native-source provider, the PTY parse otherwise) — a stale
+        // prior-turn tail or a mid-turn worker with no in-turn final assistant yields
+        // '' → return false below.
         let finalSummary: string | undefined;
         try {
             finalSummary = this.completionFinalSummary(parsedMessages, turnStartedAt);
@@ -2778,93 +2775,16 @@ export class CliProviderInstance implements ProviderInstance {
         // stall fire so a genuinely-wedged worker is still surfaced.
         if (!finalSummary) return false;
 
-        LOG.warn('CLI', `[${this.type}] reconciling pure-PTY mesh completion from the stall path for session ${this.instanceId} `
+        // Telemetry keeps the historical per-class source strings so traces and
+        // dashboards stay comparable across the unification.
+        const diagnosticSource = profile.class === 'pure-pty'
+            ? 'stall_pure_pty_transcript_completion'
+            : 'stall_native_source_transcript_completion';
+        LOG.warn('CLI', `[${this.type}] reconciling ${profile.class} mesh completion from the stall path for session ${this.instanceId} `
             + `task=${taskId ?? '(none)'} — PTY is idle-quiet with an in-turn final assistant message but the completion `
-            + `event never fired (pure-PTY provider); emitting it instead of a false monitor:no_progress.`);
-        if (this.isMeshWorkerSession()) {
-            traceMeshEventStage('fired', this.meshTraceCtx(), 'stall_pure_pty_transcript_completion');
-        }
-        this.emitGeneratingCompleted({
-            chatTitle: '',
-            duration: undefined,
-            timestamp: Date.now(),
-            taskId,
-            finalSummary,
-            evidenceLevel: 'transcript',
-            completionDiagnostic: { source: 'stall_pure_pty_transcript_completion' },
-        });
-        return true;
-    }
-
-    /**
-     * KIMI-NATIVE-SOURCE-COMPLETION-EMIT (Fix 3): stall-path completion reconcile for a
-     * NATIVE-SOURCE provider (transcriptAuthority=provider + nativeHistory — e.g. kimi,
-     * whose authoritative transcript is ~/.kimi-code/.../wire.jsonl). Like the pure-PTY
-     * class, a native-source worker that submits a prompt while already idle can collapse
-     * idle→idle so agent:generating_completed never emits; its PTY then goes screen-quiet
-     * the instant the answer renders, and the status-agnostic no-progress watchdog
-     * (checkMeshWorkerStall) misreads that finished-but-static idle as a wedge and would
-     * false-fire monitor:no_progress. sampleNativeTranscriptProgress only re-arms while the
-     * transcript is STILL ADVANCING; once the turn is done the transcript is static and the
-     * sample stops rescuing — so the stall path needs this decisive completion check for the
-     * finished-and-quiet case. tryReconcilePurePtyCompletionForStall does NOT cover this
-     * class (isPurePtyTranscriptProvider is false for a native-source provider), so it runs
-     * as a fallback here.
-     *
-     * Mutually exclusive with the pure-PTY path by construction: a provider is either
-     * native-source (this method) or pure-PTY (that method), never both. Called from
-     * checkMeshWorkerStall only after tryReconcilePurePtyCompletionForStall returned false.
-     *
-     * Evidence bar is identical to the pure-PTY / pre-cleanup paths: idle with nothing
-     * pending, the injected task's turn genuinely started, and an in-turn final assistant
-     * summary — here resolved from the native transcript by completionFinalSummary (its
-     * native-source branch reads readExternalCompletionMessages). No summary ⇒ no proof of
-     * completion ⇒ return false and let the real stall fire so a genuinely-wedged worker is
-     * still surfaced. Idempotent: a real/late emit writes the terminal ledger and the
-     * coordinator's reconcile makes any duplicate a no-op.
-     */
-    private tryReconcileNativeSourceCompletionForStall(observedStatus: string): boolean {
-        // Only the native-source class — the pure-PTY class is handled above.
-        if (!isNativeSourceCanonicalHistory(this.provider?.nativeHistory)) return false;
-        // A finished turn is idle with nothing pending. A generating/waiting session is
-        // mid-turn (the real stall path should evaluate it), so never complete it here.
-        if (observedStatus !== 'idle') return false;
-        if (this.hasAdapterPendingResponse()) return false;
-
-        const taskId = this.completingTurnTaskId();
-        // DOUBLE-EMIT guard (COMPLETION-WEAK-REARM fix1): suppress a re-emit only when this
-        // turn's completion already fired with GENUINE evidence. A prior WEAK emit is
-        // re-armable once a real generating→idle transition intervened (one-shot).
-        if (this.shouldSuppressCompletionReEmit(taskId)) {
-            return false;
-        }
-        // The injected task's own turn must have genuinely started (guards against a
-        // reused session's stale tail before this task ran).
-        if (!this.injectedTaskHasStartedGenerating()) return false;
-
-        const turnStartedAt = typeof (this.adapter as any)?.currentTurnStartedAt === 'number'
-            ? (this.adapter as any).currentTurnStartedAt as number
-            : this.meshTaskInjectedAt || undefined;
-        let parsedMessages: unknown;
-        try {
-            parsedMessages = this.adapter?.getScriptParsedStatus?.()?.messages;
-        } catch { parsedMessages = undefined; }
-        // completionFinalSummary reads the AUTHORITATIVE native transcript (wire.jsonl) for
-        // this native-source provider and turn-scopes it — so a stale prior-turn tail or a
-        // mid-turn worker with no in-turn final assistant yields '' → return false below.
-        let finalSummary: string | undefined;
-        try {
-            finalSummary = this.completionFinalSummary(parsedMessages, turnStartedAt);
-        } catch { finalSummary = undefined; }
-        // No in-turn final assistant evidence → not a proven turn-end. Let the real stall
-        // fire so a genuinely-wedged worker is still surfaced.
-        if (!finalSummary) return false;
-
-        LOG.warn('CLI', `[${this.type}] reconciling native-source mesh completion from the stall path for session ${this.instanceId} `
-            + `task=${taskId ?? '(none)'} — PTY is idle-quiet with an in-turn final assistant message in the native `
-            + `transcript but the completion event never fired; emitting it instead of a false monitor:no_progress.`);
+            + `event never fired; emitting it instead of a false monitor:no_progress.`);
         if (this.isMeshWorkerSession()) {
-            traceMeshEventStage('fired', this.meshTraceCtx(), 'stall_native_source_transcript_completion');
+            traceMeshEventStage('fired', this.meshTraceCtx(), diagnosticSource);
         }
         this.emitGeneratingCompleted({
             chatTitle: '',
@@ -2873,7 +2793,7 @@ export class CliProviderInstance implements ProviderInstance {
             taskId,
             finalSummary,
             evidenceLevel: 'transcript',
-            completionDiagnostic: { source: 'stall_native_source_transcript_completion' },
+            completionDiagnostic: { source: diagnosticSource },
         });
         return true;
     }
@@ -3282,7 +3202,7 @@ export class CliProviderInstance implements ProviderInstance {
             // 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
+            if (resolveTranscriptAuthorityProfile(this.provider).timing === 'hold'
                 && block.holdForTranscript === true
                 && waitedMs < ANTIGRAVITY_HOLD_HARD_CAP_MS
                 && this.antigravityHoldPtyStillActive()) {
@@ -3466,9 +3386,9 @@ export class CliProviderInstance implements ProviderInstance {
     }
 
     /**
-     * COMPLETION-WEAK-REARM (fix1): the double-emit guard shared by the three transcript
-     * re-emit paths (flushMeshCompletionBeforeCleanup, tryReconcilePurePtyCompletionForStall,
-     * tryReconcileNativeSourceCompletionForStall). Returns true when a re-emit for `taskId`
+     * COMPLETION-WEAK-REARM (fix1): the double-emit guard shared by the transcript
+     * re-emit paths (flushMeshCompletionBeforeCleanup,
+     * tryReconcileTranscriptCompletionForStall). Returns true when a re-emit for `taskId`
      * must be SUPPRESSED because this turn's completion already fired with strong evidence.
      *
      * The defect this replaces: the old guard short-circuited on ANY prior emit for the
@@ -3980,7 +3900,7 @@ export class CliProviderInstance implements ProviderInstance {
             fcEvidenceSource = evidence.source;
             fcFinalSummary = extractFinalSummaryFromMessages(evidence.messages as any);
         } catch { /* best-effort */ }
-        const missingEvidence = ((this.provider as any).requiresFinalAssistantBeforeIdle === true || fcEvidenceSource === 'external-native') && !fcFinalSummary;
+        const missingEvidence = (resolveTranscriptAuthorityProfile(this.provider).timing === 'floor' || fcEvidenceSource === 'external-native') && !fcFinalSummary;
         // Mirror the short-generating idle path's suppression: a provider that
         // requires a final assistant (or external-native history) with NO confirmed
         // summary and NO mesh context emits nothing — the session is idle with no
@@ -4285,7 +4205,7 @@ export class CliProviderInstance implements ProviderInstance {
                     // (the mid-turn point-sample that triggered this whole false-idle bug) is treated
                     // as weak/held, not fired as a genuine completion. A real shortFinalSummary being
                     // present still clears the gate (the !shortFinalSummary guard is unchanged).
-                    const missingEvidence = ((this.provider as any).requiresFinalAssistantBeforeIdle === true
+                    const missingEvidence = (resolveTranscriptAuthorityProfile(this.provider).timing === 'floor'
                         || shortEvidenceSource === 'external-native'
                         || shortEvidenceSource === 'unavailable') && !shortFinalSummary;
                     if (missingEvidence) {

package/src/providers/transcript-evidence.ts

@@ -0,0 +1,105 @@
+/**
+ * Transcript authority profile — the single place that classifies a provider
+ * for completion/stall/redrive decisions.
+ *
+ * Historically five predicates coexisted (transcriptAuthority, nativeHistory
+ * presence, adapter chatMessagesOwnedExternally, isPurePtyTranscriptProvider,
+ * and the two completion-timing flags) and every judgment site combined a
+ * different subset — each recurring "pure-PTY gate excludes native-source"
+ * defect (kimi reconcile, antigravity tail/guard, codex floor, STARTED
+ * redrive) was an instance of a site enumerating only some classes. This
+ * module makes the enumeration itself the shared artifact: sites consume a
+ * profile, never the raw predicates.
+ *
+ * Design: docs/design/2026-07-25-transcript-authority-unification.md (root
+ * repo). This file is Phase P0 (layer A — pure, synchronous classification).
+ * Layer B (the evidence-query choke point) lands in later phases.
+ *
+ * Rule for NEW code: call resolveTranscriptAuthorityProfile() — do not call
+ * isPurePtyTranscriptProvider / isNativeSourceCanonicalHistory or read the
+ * timing flags directly (annotate `// authority-ok: <why>` where a raw read
+ * is genuinely about something other than completion classification).
+ */
+
+import type { ProviderCanonicalHistoryConfig } from './contracts.js';
+import { isPurePtyTranscriptProvider } from '../cli-adapters/provider-cli-shared.js';
+import { isNativeSourceCanonicalHistory } from '../config/chat-history.js';
+
+/** Where the authoritative transcript for completion evidence lives. */
+export type TranscriptClass = 'native-source' | 'pure-pty' | 'daemon-owned';
+
+/**
+ * When a completion may be emitted relative to the PTY idle verdict:
+ *  - 'hold'      — idle holds for the native transcript to land (antigravity).
+ *  - 'floor'     — idle without a final assistant holds under the CANON-C
+ *                  min-elapsed floor (codex / kimi / cursor / opencode).
+ *  - 'immediate' — emit immediately; a write-lag native source upgrades the
+ *                  weak emit on reconcile (claude), daemon-owned emits plainly.
+ */
+export type CompletionTiming = 'hold' | 'floor' | 'immediate';
+
+export interface TranscriptAuthorityProfile {
+    class: TranscriptClass;
+    timing: CompletionTiming;
+    /** transcriptAuthority === 'provider' — provider parser output is canonical. */
+    providerOwnsTranscript: boolean;
+    /**
+     * False ⇒ this class may run whole turns without PTY generating_started /
+     * generating_completed events, so the ABSENCE of a turn-start event must
+     * never be read as "dispatch not consumed" (the STARTED-redrive rule,
+     * generalized). True only where PTY turn events are reliable.
+     */
+    emitsPtyTurnEvents: boolean;
+    /** The provider's native history config when the class is native-source. */
+    nativeHistory?: ProviderCanonicalHistoryConfig;
+}
+
+/**
+ * Structural input — matches how judgment sites actually hold providers
+ * (CliProviderModule / ProviderModule / nullable this.provider). Null or
+ * undefined resolves to the conservative daemon-owned/immediate default,
+ * matching the established null-provider ⇒ not-pure-PTY contract.
+ */
+export interface TranscriptAuthorityInput {
+    transcriptAuthority?: 'provider' | 'daemon';
+    nativeHistory?: ProviderCanonicalHistoryConfig;
+    tui?: Record<string, unknown>;
+    requiresFinalAssistantBeforeIdle?: boolean;
+    holdCompletionForTranscript?: boolean;
+}
+
+export function resolveTranscriptAuthorityProfile(
+    provider: TranscriptAuthorityInput | null | undefined,
+): TranscriptAuthorityProfile {
+    if (!provider) {
+        return { class: 'daemon-owned', timing: 'immediate', providerOwnsTranscript: false, emitsPtyTurnEvents: true };
+    }
+
+    const nativeSource = isNativeSourceCanonicalHistory(provider.nativeHistory);
+    const transcriptClass: TranscriptClass = nativeSource
+        ? 'native-source'
+        : isPurePtyTranscriptProvider(provider)
+            ? 'pure-pty'
+            : 'daemon-owned';
+
+    const timing: CompletionTiming = provider.holdCompletionForTranscript === true
+        ? 'hold'
+        : provider.requiresFinalAssistantBeforeIdle === true
+            ? 'floor'
+            : 'immediate';
+
+    // PTY turn events are unreliable for (a) pure-PTY (turns collapse
+    // idle→idle; the parser, not the PTY event stream, notices the turn) and
+    // (b) native-source classes that hold/floor precisely because their turn
+    // activity lives in the native transcript rather than the PTY.
+    const emitsPtyTurnEvents = transcriptClass === 'daemon-owned'
+        || (transcriptClass === 'native-source' && timing === 'immediate');
+
+    return {
+        class: transcriptClass,
+        timing,
+        providerOwnsTranscript: provider.transcriptAuthority === 'provider',
+        emitsPtyTurnEvents,
+        ...(nativeSource && provider.nativeHistory ? { nativeHistory: provider.nativeHistory } : {}),
+    };
+}

package/src/repo-mesh-types.ts

@@ -1183,6 +1183,14 @@ export interface LocalMeshNodeEntry {
      * first envelope carrying it is ingested.
      */
     reportedMemberState?: MeshReportedMemberState;
+    /**
+     * Versioned per-machine runtime facts bundle (MeshNodeFacts — deploy-lag
+     * visibility design §a). Remote nodes: ingested wholesale from the
+     * git_status envelope's reporterNodeFacts. Self/worktree nodes: built by
+     * the SAME producer (buildLocalNodeFacts). Relayed opaquely — surfaces
+     * must pass the object through, never rebuild it field-by-field.
+     */
+    nodeFacts?: import('@adhdev/mesh-shared').MeshNodeFacts;
     /**
      * The operator-set machine nickname (config.machineNickname) of the daemon
      * that owns this node's workspace. The local coordinator stamps its own
@@ -1302,6 +1310,14 @@ export interface RepoMeshStatus {
      * an optional `stats` operational rollup (durations / retries).
      */
     missions?: (MeshMissionSummary | MeshMissionSlimSummary)[];
+    /**
+     * Preview-deploy freshness rollup (deploy-lag visibility): stamped by the
+     * dashboard mesh_status when the repo has a preview pipeline. Shape is
+     * daemon-defined (mesh/preview-freshness.ts) — `currentMainCommit` is the
+     * global deploy-lag anchor the dashboard compares nodeFacts.daemonBuild
+     * against. Omitted for repos without the pipeline and by older daemons.
+     */
+    previewFreshness?: Record<string, unknown>;
     /**
      * MAGI cross-verification activity, reconstructed from the mesh ledger
      * (magi_dispatched / magi_synthesis entries) and folded in so the dashboard's
@@ -1476,6 +1492,13 @@ export interface RepoMeshNodeStatus {
      * (scope/isDaemonAffecting flags). Omitted when the build is current.
      */
     staleDaemonBuild?: Record<string, unknown>;
+    /**
+     * Versioned per-machine runtime facts bundle (MeshNodeFacts). Opaque
+     * pass-through from the node record — see the node-level field doc.
+     * Carries the daemon build COMMIT (not just the version string), which is
+     * the deploy-lag anchor the dashboard renders.
+     */
+    nodeFacts?: import('@adhdev/mesh-shared').MeshNodeFacts;
     error?: string;
 }