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

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

@@ -471,19 +471,26 @@ export interface AssignedTaskTerminalEvidence {
 // dispatch timestamp, or a tail containing nothing dated at/after dispatch all yield false, so the
 // caller falls through to its normal re-drive decision. The poll can only PREVENT a re-drive of a
 // working session, never create or suppress a completion.
-export async function pollAssignedTaskInTurnProgress(
+// ---------------------------------------------------------------------------
+// Shared assigned-task read_chat skeleton (P1 of the transcript-authority
+// unification — root repo docs/design/2026-07-25-transcript-authority-unification.md).
+// pollAssignedTaskInTurnProgress ('turn-progress') and
+// pollAssignedTaskTerminalEvidence ('terminal-evidence') previously duplicated
+// this fetch verbatim; both are delegation shells over this one skeleton so a
+// future purpose (or the reconcile-loop consumers in P3) cannot fork the
+// transport semantics again. Inconclusive — no worker, no transport, transport
+// error, or an explicit success:false — is null; callers keep their
+// conservative fallbacks ("couldn't tell ≠ idle").
+// ---------------------------------------------------------------------------
+async function fetchAssignedTaskChatTail(
     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<boolean> {
+    row: { assignedSessionId?: string; assignedNodeId?: string; assignedProviderType?: string },
+    tailLimit = 10,
+): Promise<Record<string, unknown> | null> {
     const sessionId = readNonEmptyString(row.assignedSessionId);
     const nodeId = readNonEmptyString(row.assignedNodeId);
-    if (!sessionId || !nodeId) return false; // no worker to read
-
-    // A dispatch boundary is REQUIRED: without it a reused session's prior-task tail would read as
-    // progress on THIS task and suppress the re-drive forever.
-    const dispatchedAtMs = Date.parse(readNonEmptyString(row.dispatchTimestamp));
-    if (!Number.isFinite(dispatchedAtMs)) return false;
+    if (!sessionId || !nodeId) return null; // no worker to read
 
     const node = (mesh.nodes ?? []).find(n => n.id === nodeId);
     const nodeDaemonId = readNonEmptyString(node?.daemonId);
@@ -496,27 +503,76 @@ export async function pollAssignedTaskInTurnProgress(
     const readArgs: Record<string, unknown> = {
         sessionId,
         targetSessionId: sessionId,
-        tailLimit: 10,
+        tailLimit,
         ...(node?.workspace ? { workspace: node.workspace } : {}),
         ...(providerType ? { agentType: providerType, providerType } : {}),
     };
 
-    let payload: Record<string, unknown> | null = null;
     try {
         if (isLocalNode) {
             const result = await components.commandHandler?.handle('read_chat', readArgs);
-            if (result && (result as { success?: boolean }).success === false) return false;
-            payload = unwrapReadChatPayload(result);
-        } else if (components.dispatchMeshCommand) {
+            if (result && (result as { success?: boolean }).success === false) return null;
+            return unwrapReadChatPayload(result);
+        }
+        if (components.dispatchMeshCommand) {
             const result = await components.dispatchMeshCommand(nodeDaemonId, 'read_chat', readArgs);
-            payload = unwrapReadChatPayload(result);
-            if (payload && (payload as { success?: boolean }).success === false) return false;
-        } else {
-            return false; // remote node, no P2P transport — can't read this tick
+            const payload = unwrapReadChatPayload(result);
+            if (payload && (payload as { success?: boolean }).success === false) return null;
+            return payload;
         }
+        return null; // remote node, no P2P transport — can't read this tick
     } catch {
-        return false; // transport error / session gone → inconclusive, let the caller decide
+        return null; // transport error / session gone → inconclusive, let the caller decide
     }
+}
+
+/**
+ * Purpose-tagged coordinator-side evidence query — the remote half of the
+ * transcript-authority choke point (P1). Existing callers keep the original
+ * poll* shells below; new consumers (the reconcile loop's early-arm / redrive
+ * sites in P3) should enter here so the purpose vocabulary — not another
+ * ad-hoc gate — expresses what is being asked of the worker transcript.
+ */
+export type AssignedTaskEvidencePurpose = 'turn-progress' | 'terminal-evidence';
+
+export interface AssignedTaskCompletionEvidence {
+    purpose: AssignedTaskEvidencePurpose;
+    /** "Did the worker START this task's turn" — post-dispatch agent bubble. */
+    inTurnProgress: boolean;
+    /** "Did the worker FINISH this task's turn" — populated for 'terminal-evidence'. */
+    terminal: AssignedTaskTerminalEvidence | null;
+}
+
+export async function resolveAssignedTaskCompletionEvidence(
+    components: DaemonComponents,
+    mesh: { id: string; nodes?: Array<{ id: string; daemonId?: string; workspace?: string }> },
+    row: { id: string; assignedSessionId?: string; assignedNodeId?: string; assignedProviderType?: string; dispatchTimestamp?: string },
+    purpose: AssignedTaskEvidencePurpose,
+): Promise<AssignedTaskCompletionEvidence> {
+    if (purpose === 'turn-progress') {
+        const inTurnProgress = await pollAssignedTaskInTurnProgress(components, mesh, row);
+        return { purpose, inTurnProgress, terminal: null };
+    }
+    const terminal = await pollAssignedTaskTerminalEvidence(components, mesh, row);
+    // A proven turn-end implies the turn also started.
+    return { purpose, inTurnProgress: terminal != null, terminal };
+}
+
+export async function pollAssignedTaskInTurnProgress(
+    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<boolean> {
+    const sessionId = readNonEmptyString(row.assignedSessionId);
+    const nodeId = readNonEmptyString(row.assignedNodeId);
+    if (!sessionId || !nodeId) return false; // no worker to read
+
+    // A dispatch boundary is REQUIRED: without it a reused session's prior-task tail would read as
+    // progress on THIS task and suppress the re-drive forever.
+    const dispatchedAtMs = Date.parse(readNonEmptyString(row.dispatchTimestamp));
+    if (!Number.isFinite(dispatchedAtMs)) return false;
+
+    const payload = await fetchAssignedTaskChatTail(components, mesh, row);
     if (!payload) return false;
 
     const messages = Array.isArray(payload.messages) ? payload.messages as ChatMessage[] : [];
@@ -542,38 +598,8 @@ export async function pollAssignedTaskTerminalEvidence(
     const nodeId = readNonEmptyString(row.assignedNodeId);
     if (!sessionId || !nodeId) return null; // no worker to read
 
-    const node = (mesh.nodes ?? []).find(n => n.id === nodeId);
-    const nodeDaemonId = readNonEmptyString(node?.daemonId);
-    const localDaemonId = readNonEmptyString((components as { statusInstanceId?: string }).statusInstanceId);
-    const isLocalNode = !nodeDaemonId
-        || daemonIdsEquivalent(nodeDaemonId, localDaemonId)
-        || !!components.instanceManager.getInstance(sessionId);
-
     const providerType = readNonEmptyString(row.assignedProviderType);
-    const readArgs: Record<string, unknown> = {
-        sessionId,
-        targetSessionId: sessionId,
-        tailLimit: 10,
-        ...(node?.workspace ? { workspace: node.workspace } : {}),
-        ...(providerType ? { agentType: providerType, providerType } : {}),
-    };
-
-    let payload: Record<string, unknown> | null = null;
-    try {
-        if (isLocalNode) {
-            const result = await components.commandHandler?.handle('read_chat', readArgs);
-            if (result && (result as { success?: boolean }).success === false) return null;
-            payload = unwrapReadChatPayload(result);
-        } else if (components.dispatchMeshCommand) {
-            const result = await components.dispatchMeshCommand(nodeDaemonId, 'read_chat', readArgs);
-            payload = unwrapReadChatPayload(result);
-            if (payload && (payload as { success?: boolean }).success === false) return null;
-        } else {
-            return null; // remote node, no P2P transport — can't read this tick
-        }
-    } catch {
-        return null; // transport error / session gone → inconclusive, let the caller decide
-    }
+    const payload = await fetchAssignedTaskChatTail(components, mesh, row);
     if (!payload) return null;
 
     // Only a settled-idle session is a turn-end; a generating/waiting session is mid-turn and

package/src/mesh/mesh-node-identity.ts

@@ -15,7 +15,8 @@ import type { ProviderLoader } from '../providers/provider-loader.js';
 import { detectCLI, getCachedProviderVersions } from '../detection/cli-detector.js';
 import { getDaemonBuildInfo } from '../build-info.js';
 import { getGitRepoStatus } from '../git/git-status.js';
-import { normalizeGitStatus as sharedNormalizeGitStatus, pickBestTransitGitStatus as sharedPickBestTransitGitStatus, summarizeGitShape as sharedSummarizeGitShape, normalizeMeshNodeId, daemonIdsEquivalent, meshWorkspacesEquivalent, sessionIdsEquivalent, withStatusProbeMarker } from '@adhdev/mesh-shared';
+import { normalizeGitStatus as sharedNormalizeGitStatus, pickBestTransitGitStatus as sharedPickBestTransitGitStatus, summarizeGitShape as sharedSummarizeGitShape, normalizeMeshNodeId, normalizeMeshNodeFacts, daemonIdsEquivalent, meshWorkspacesEquivalent, sessionIdsEquivalent, withStatusProbeMarker } from '@adhdev/mesh-shared';
+import { buildLocalNodeFacts } from './node-facts.js';
 import type { MeshReportedMemberState } from '../repo-mesh-types.js';
 import { LOG } from '../logging/logger.js';
 import { getSessionHostSurfaceKind } from '../session-host/runtime-surface.js';
@@ -240,7 +241,7 @@ export function buildMeshNodeMachineIdentity(node: Record<string, unknown>, opts
     const hostname = readMeshNodeHostname(node);
     const machineName = readMeshNodeDisplayMachineName(node);
     const coordinatorHostname = readStringValue(opts.coordinatorHostname);
-    const machineIdMatches = Boolean(opts.localMachineId && machineId && opts.localMachineId === machineId);
+    const machineIdMatches = Boolean(opts.localMachineId && machineId && daemonIdsEquivalent(opts.localMachineId, machineId));
     const daemonIdMatches = Boolean(opts.localDaemonId && daemonId && daemonIdsEquivalent(opts.localDaemonId, daemonId));
     const hostnameMatches = Boolean(
         normalizeMeshHostname(hostname)
@@ -328,6 +329,7 @@ export function recordInlineMeshDirectGitTruth(
     reporterProviderVersions: Record<string, string> | null;
     reporterDaemonBuildVersion: string | null;
     reportedMemberState: MeshReportedMemberState | null;
+    nodeFacts: import('@adhdev/mesh-shared').MeshNodeFacts | null;
 } {
     if (!node || typeof node !== 'object' || Array.isArray(node)) {
         return {
@@ -337,6 +339,7 @@ export function recordInlineMeshDirectGitTruth(
             reporterProviderVersions: null,
             reporterDaemonBuildVersion: null,
             reportedMemberState: null,
+            nodeFacts: null,
         };
     }
     const checkedAt = readNumberValue(git.lastCheckedAt) ?? Date.now();
@@ -433,6 +436,20 @@ export function recordInlineMeshDirectGitTruth(
             node.reportedMemberState = mirrored;
         }
     }
+    // Versioned facts bundle (deploy-lag visibility design §a). Remote: ingest the
+    // envelope's reporterNodeFacts WHOLESALE (opaque — unknown future fields ride
+    // through). Self/worktree: the local probe bypasses handleGitCommand, so build
+    // the bundle with the SAME producer the envelope uses — the two paths cannot
+    // drift on a per-field basis anymore. Skipped (no stamp churn) when a remote
+    // envelope predates the bundle.
+    if (!isLocalSource) {
+        const remoteFacts = normalizeMeshNodeFacts((git as { reporterNodeFacts?: unknown }).reporterNodeFacts);
+        if (remoteFacts) node.nodeFacts = remoteFacts;
+    } else {
+        try {
+            node.nodeFacts = buildLocalNodeFacts({ providerVersions: reporterProviderVersions ?? null });
+        } catch { /* facts stamp is best-effort observability */ }
+    }
     return {
         reporterPlatform,
         reporterArch,
@@ -440,6 +457,9 @@ export function recordInlineMeshDirectGitTruth(
         reporterProviderVersions,
         reporterDaemonBuildVersion,
         reportedMemberState: (!isLocalSource ? (node.reportedMemberState ?? null) : null) as MeshReportedMemberState | null,
+        // Bundle rides to persistence so the facts (incl. build COMMIT — the
+        // deploy-lag anchor) survive a config reload / coordinator restart.
+        nodeFacts: (node.nodeFacts ?? null) as import('@adhdev/mesh-shared').MeshNodeFacts | null,
     };
 }
 
@@ -555,6 +575,7 @@ export function persistNodeReporterPlatform(
         reporterProviderVersions?: Record<string, string> | null;
         reporterDaemonBuildVersion?: string | null;
         reportedMemberState?: MeshReportedMemberState | null;
+        nodeFacts?: import('@adhdev/mesh-shared').MeshNodeFacts | null;
     },
 ): void {
     if (meshSource !== 'local_config') return;
@@ -570,13 +591,15 @@ export function persistNodeReporterPlatform(
     // per-machine runtime facts only (versions + build) — slots are coordinator-owned
     // config, not reported (REMOTE-NODE-SLOTS-COORDINATOR-LOCAL fix).
     const reportedMemberState = reporter.reportedMemberState ?? undefined;
+    const nodeFacts = reporter.nodeFacts ?? undefined;
     if (
         !reportedPlatform &&
         !reportedArch &&
         !reportedMachineNickname &&
         !reportedProviderVersions &&
         !reportedDaemonBuildVersion &&
-        !reportedMemberState
+        !reportedMemberState &&
+        !nodeFacts
     ) {
         return;
     }
@@ -588,6 +611,7 @@ export function persistNodeReporterPlatform(
             reportedProviderVersions,
             reportedDaemonBuildVersion,
             reportedMemberState,
+            nodeFacts,
         }))
         .catch(() => { /* best-effort self-heal; never block status assembly */ });
 }
@@ -1516,6 +1540,16 @@ export function finalizeMeshNodeStatus(args: {
         liveTruthProbed,
         directTruthUnavailable,
     });
+    // Deploy-lag visibility: surface the git probe's daemonBuildBehind as the
+    // top-level staleDaemonBuild node field — same contract as the MCP
+    // mesh_status surface (mesh-tools-status.ts). The dashboard Status tab's
+    // stale-build badge reads this field; before this stamp the dashboard
+    // surface never received it (and normalizeGitStatus additionally dropped
+    // it from relayed remote statuses), so the badge was a dead path.
+    const gitForBuildLag = readObjectRecord(status.git);
+    if (gitForBuildLag.daemonBuildBehind && typeof gitForBuildLag.daemonBuildBehind === 'object') {
+        status.staleDaemonBuild = gitForBuildLag.daemonBuildBehind;
+    }
     const bootstrap = readObjectRecord(node?.worktreeBootstrap);
     if (node?.isLocalWorktree && readStringValue(bootstrap.status)) {
         status.worktreeBootstrap = bootstrap;

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

@@ -8,6 +8,7 @@ import { LOG } from '../logging/logger.js';
 import { appendLedgerEntry } from './mesh-ledger.js';
 import { buildMeshNodeCapabilityTags, nodeSatisfiesRequiredTags, claimNextTask, updateTaskStatus, getQueue, recordTaskAutoLaunch, getActiveDirectDispatches, isTaskReadonly, taskDependenciesSatisfied, meshTaskNotBeforeReady, meshTaskPriorityRank, requeueTask } from './mesh-work-queue.js';
 import type { MeshWorkQueueEntry } from './mesh-work-queue.js';
+import { resolveTranscriptAuthorityProfile } from '../providers/transcript-evidence.js';
 import { fastForwardMeshNode } from './mesh-fast-forward.js';
 import { createSessionDelivery, updateSessionDeliveryStatus } from './mesh-delivery-policy.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
@@ -433,6 +434,33 @@ function deliverTaskToSession(
 // the mesh_status per-node session filter, and the read_chat node scope guard all
 // share one comparison rule instead of drifting module-private copies.
 
+/**
+ * Resolve the transcript-authority profile of the LIVE claiming session's
+ * provider module (runtime capability, not manifest — a manifest may declare
+ * nativeHistory the live-loaded session doesn't have). Row-lean subset: the
+ * nativeHistory config itself stays local. Undefined when the session isn't
+ * locally observable — the row simply carries no stamp and consumers fall
+ * back to local resolution (older-daemon rows look the same).
+ */
+function resolveClaimingSessionTranscriptProfile(
+    components: DaemonComponents,
+    sessionId: string,
+): MeshWorkQueueEntry['assignedTranscriptProfile'] {
+    try {
+        const instances = components.instanceManager?.getByCategory?.('cli') || [];
+        const inst = instances.find((i: any) => {
+            const sid = i?.getState?.().instanceId;
+            return typeof sid === 'string' && sid && sessionIdsEquivalent(sid, sessionId);
+        }) as { provider?: unknown } | undefined;
+        const provider = inst?.provider;
+        if (!provider || typeof provider !== 'object') return undefined;
+        const profile = resolveTranscriptAuthorityProfile(provider as Parameters<typeof resolveTranscriptAuthorityProfile>[0]);
+        return { class: profile.class, timing: profile.timing, emitsPtyTurnEvents: profile.emitsPtyTurnEvents };
+    } catch {
+        return undefined;
+    }
+}
+
 export function tryAssignQueueTask(
     components: DaemonComponents,
     meshId: string,
@@ -589,10 +617,16 @@ export function tryAssignQueueTask(
     // worktree sessions. Without it, every sibling worktree session on this daemon could
     // claim the same convergence intent and race push/production-deploy (the 4-way fan-out).
     const nodeIsWorktree = node?.isLocalWorktree === true;
+    // P1 transcript-authority stamp: the claim runs on the daemon that owns the
+    // session, so the LIVE provider module (runtime capability, not manifest) is
+    // resolvable here — classify once and persist it on the row so coordinator-side
+    // gates (early-arm / redrive) can classify this worker without local access.
+    const assignedTranscriptProfile = resolveClaimingSessionTranscriptProfile(components, sessionId);
     const task = claimNextTask(meshId, nodeId, sessionId, capabilityTags, {
         providerType,
         ...(providerMaxParallel !== undefined ? { providerMaxParallel } : {}),
         nodeIsWorktree,
+        ...(assignedTranscriptProfile ? { assignedTranscriptProfile } : {}),
     });
     if (!task) {
         return false;

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

@@ -77,8 +77,7 @@ import {
     resolveReconcileIntervalMs,
 } from './mesh-reconcile-config.js';
 import { pullRemoteNodeQueues, pullPendingEventsFromNode, reprobeWorkerStatus } from './mesh-remote-event-pull.js';
-import { isPurePtyTranscriptProvider } from '../cli-adapters/provider-cli-shared.js';
-import { isNativeSourceCanonicalHistory } from '../config/chat-history.js';
+import { resolveTranscriptAuthorityProfile } from '../providers/transcript-evidence.js';
 import { runDiskRetentionSweep, detectAndSignalOrphanWorktrees } from './mesh-disk-retention.js';
 import {
     reconcileUnterminatedDirectDispatches,
@@ -792,53 +791,40 @@ function assignedRowLiveStatusIsAwaitingApproval(
     }
 }
 
-// EARLY-IDLE-COMPLETION-FALSE-POSITIVE — resolve whether the assigned session's provider is
-// the pure-PTY transcript class (kimi and kin — no native history, no provider authority), from
-// the LOCAL instance when it is present. Returns:
-//   true      → local instance is a pure-PTY provider (the class the early rescue exists for)
-//   false     → local instance is NOT pure-PTY (native / provider-authoritative)
-//   undefined → no local instance (remote worker / gone / id-form skew) — pure-PTY unknowable here
-// A remote pure-PTY worker is handled by the reprobe path (a fresh-idle read positively confirms
-// the session is settled before the streak accrues), not by this local-only capability check.
-function resolveLocalSessionPurePty(components: DaemonComponents, sessionId: string): boolean | undefined {
-    try {
-        const instances = components.instanceManager?.getByCategory?.('cli') || [];
-        const inst = instances.find((i: any) => {
-            const sid = readNonEmptyString(i?.getState?.().instanceId);
-            return sid && sessionIdsEquivalent(sid, sessionId);
-        }) as { provider?: unknown } | undefined;
-        if (!inst) return undefined; // remote / gone / id-form skew — not locally observable
-        const provider = inst.provider;
-        if (!provider || typeof provider !== 'object') return undefined;
-        return isPurePtyTranscriptProvider(provider as Parameters<typeof isPurePtyTranscriptProvider>[0]);
-    } catch {
-        return undefined;
+/**
+ * P3 of the transcript-authority unification (root repo docs/design/
+ * 2026-07-25-transcript-authority-unification.md): resolve the assigned
+ * worker's transcript-authority profile. The claim-time row stamp comes FIRST
+ * — it was written by the daemon that OWNS the session from its LIVE provider
+ * module, so it classifies a REMOTE worker this coordinator cannot resolve
+ * locally (the structural fix for the "remote class unknowable → reprobe-only"
+ * blind spot). Falls back to the local instance for pre-stamp rows / direct
+ * dispatches; undefined for an older-daemon remote row — callers keep their
+ * conservative reprobe fallbacks.
+ */
+function resolveAssignedTranscriptProfile(
+    components: DaemonComponents,
+    row: {
+        assignedSessionId?: string;
+        assignedTranscriptProfile?: { class: string; timing: string; emitsPtyTurnEvents: boolean };
+    },
+): { class: string; timing: string; emitsPtyTurnEvents: boolean } | undefined {
+    const stamped = row.assignedTranscriptProfile;
+    if (stamped && typeof stamped === 'object' && typeof stamped.emitsPtyTurnEvents === 'boolean') {
+        return stamped;
     }
-}
-
-// KIMI-NATIVE-SOURCE early-idle arm — resolve whether the assigned session's provider is a
-// NATIVE-SOURCE provider (transcriptAuthority=provider + on-disk nativeHistory — e.g. kimi's
-// wire.jsonl), from the LOCAL instance when it is present. Returns:
-//   true      → local instance is a native-source provider (kimi and kin)
-//   false     → local instance is NOT native-source (pure-PTY / daemon-owned transcript)
-//   undefined → no local instance (remote worker / gone / id-form skew) — unknowable here
-// This is the mirror of resolveLocalSessionPurePty for the class that DOES have an
-// authoritative on-disk transcript: a native-source worker that collapses idle→idle (never
-// emitting generating_started so taskDeliveryConsumed stays false) would otherwise be blocked
-// by the turn-not-started hold, leaving a finished turn 'assigned' until the 15-min reclaim.
-// Allowing it to arm lets the transcript-evidence poll complete it promptly; the poll's
-// idle + final-assistant-after-dispatch guards remain the finality net.
-function resolveLocalSessionNativeSource(components: DaemonComponents, sessionId: string): boolean | undefined {
+    const sessionId = readNonEmptyString(row.assignedSessionId);
+    if (!sessionId) return undefined;
     try {
         const instances = components.instanceManager?.getByCategory?.('cli') || [];
         const inst = instances.find((i: any) => {
             const sid = readNonEmptyString(i?.getState?.().instanceId);
             return sid && sessionIdsEquivalent(sid, sessionId);
-        }) as { provider?: { nativeHistory?: unknown } } | undefined;
-        if (!inst) return undefined; // remote / gone / id-form skew — not locally observable
-        const provider = inst.provider;
+        }) as { provider?: unknown } | undefined;
+        const provider = inst?.provider;
         if (!provider || typeof provider !== 'object') return undefined;
-        return isNativeSourceCanonicalHistory((provider as { nativeHistory?: any }).nativeHistory);
+        const profile = resolveTranscriptAuthorityProfile(provider as Parameters<typeof resolveTranscriptAuthorityProfile>[0]);
+        return { class: profile.class, timing: profile.timing, emitsPtyTurnEvents: profile.emitsPtyTurnEvents };
     } catch {
         return undefined;
     }
@@ -870,7 +856,13 @@ async function evaluateEarlyIdleTranscriptArm(
     components: DaemonComponents,
     mesh: { id: string; nodes?: Array<{ id: string; daemonId?: string; workspace?: string }> },
     store: MeshRuntimeStore,
-    row: { id: string; assignedSessionId?: string; assignedNodeId?: string; assignedProviderType?: string },
+    row: {
+        id: string;
+        assignedSessionId?: string;
+        assignedNodeId?: string;
+        assignedProviderType?: string;
+        assignedTranscriptProfile?: { class: string; timing: string; emitsPtyTurnEvents: boolean };
+    },
     localDaemonId?: string,
     selfIds: string[] = [],
 ): Promise<boolean> {
@@ -921,26 +913,21 @@ async function evaluateEarlyIdleTranscriptArm(
 
     // (b) TURN-START evidence (guards the boot-window / preamble false positive).
     if (store.taskDeliveryConsumed(mesh.id, row.id)) return true; // worker emitted generating_started
-    // Delivery never consumed. Preserve the kimi rescue ONLY for the LOCAL pure-PTY class (which
-    // never emits generating_started); a native/provider-authoritative local worker that hasn't
-    // started its turn must NOT be armed off a boot-window idle. For a remote worker (pure-PTY
-    // unknowable here) the positive-idle reprobe in (a) is the gate — allow accrual and let the poll
-    // enforce post-dispatch + trailing-tool-activity finality.
-    const localPurePty = resolveLocalSessionPurePty(components, sessionId);
-    if (localPurePty === true) return true;   // local pure-PTY — the class this rescue targets
-    if (localPurePty === false) {
-        // Not the pure-PTY class. A NATIVE-SOURCE provider (transcriptAuthority=provider +
-        // nativeHistory — e.g. kimi) can ALSO collapse idle→idle and never emit
-        // generating_started (so taskDeliveryConsumed stays false), yet its finished turn is
-        // provable from its authoritative on-disk transcript. Arm it too so it completes via
-        // the transcript-evidence poll instead of sitting 'assigned' until the 15-min
-        // DELIVERED_NO_TURN_DEADLINE_MS reclaim. A genuinely daemon-owned / non-native worker
-        // that hasn't started its turn is still held (returns false).
-        const localNativeSource = resolveLocalSessionNativeSource(components, sessionId);
-        if (localNativeSource === true) return true; // native-source — provable via its transcript
-        return false;                                // daemon-owned, turn not started — hold
-    }
-    return verdict === 'UNKNOWN';             // remote, unknowable class — trust the (a) reprobe
+    // Delivery never consumed. Classify via the transcript-authority profile (P3):
+    // a class that runs turns WITHOUT reliable PTY turn events (pure-PTY, or a
+    // native-source floor/hold provider — emitsPtyTurnEvents=false) legitimately
+    // never emits generating_started, and its finished turn is provable from its
+    // transcript — arm it and let the transcript-evidence poll enforce the
+    // post-dispatch + trailing-tool finality net. A class with RELIABLE PTY turn
+    // events (daemon-owned, or a write-lag native source like claude-cli) that
+    // hasn't started its turn is HELD — arming it off a boot-window idle is
+    // exactly the preamble false positive this gate exists to prevent. The
+    // claim-time row stamp classifies REMOTE workers too; an unstamped remote
+    // row (older claiming daemon) keeps the historical fallback of trusting the
+    // (a) positive-idle reprobe.
+    const profile = resolveAssignedTranscriptProfile(components, row);
+    if (profile) return profile.emitsPtyTurnEvents === false;
+    return verdict === 'UNKNOWN';             // no stamp, no local instance — trust the (a) reprobe
 }
 
 // WATCHDOG-FINALSUMMARY-LOST. When the assigned-stranded watchdog / delivered-no-turn deadline
@@ -1210,16 +1197,20 @@ async function recoverStrandedAssignedDispatches(
                 // grace at all. Live 2026-07-25: a kimi worker was re-injected the same prompt at
                 // 35s/28s/27s/43s (answering it each time) and the task then marked failed.
                 //
-                // So for that class ONLY, replace the missing event with the evidence the provider
+                // So for that class, replace the missing event with the evidence the provider
                 // actually produces: any post-dispatch agent bubble in its transcript. Found → the
                 // prompt WAS consumed and the turn is under way; hold the row (and clear the streak,
                 // since progress is positive evidence, not a deferral). Not found / unreadable → fall
-                // through unchanged. PTY-event providers never enter this branch
-                // (resolveLocalSessionNativeSource false/undefined), so their behaviour is untouched.
-                const nativeSourceRedriveCandidate = row.assignedSessionId
-                    ? resolveLocalSessionNativeSource(components, row.assignedSessionId) === true
-                    : false;
-                if (nativeSourceRedriveCandidate
+                // through unchanged. P3 generalization: the gate is the transcript-authority
+                // profile's emitsPtyTurnEvents=false (pure-PTY AND native-source floor/hold —
+                // every class whose turn start is not a PTY event), resolved from the claim-time
+                // row stamp FIRST so a REMOTE worker of this class is finally covered too (the
+                // original fix was local-only). Reliable-PTY-event providers never enter this
+                // branch, so their behaviour is untouched.
+                const redriveProfile = row.assignedSessionId
+                    ? resolveAssignedTranscriptProfile(components, row)
+                    : undefined;
+                if (redriveProfile?.emitsPtyTurnEvents === false
                     && await pollAssignedTaskInTurnProgress(components, { id: meshId, nodes: mesh.nodes }, row)) {
                     deliveredUnconsumedUnknownStreak.delete(shortStreakKey);
                     traceMeshEventDrop('short_redrive_deferred_native_source_progress', {
@@ -1228,7 +1219,7 @@ async function recoverStrandedAssignedDispatches(
                         nodeId: row.assignedNodeId,
                         meshId,
                         event: 'agent:generating_started',
-                    }, `native_source_in_turn_progress (verdict ${verdict})`);
+                    }, `${redriveProfile.class}_in_turn_progress (verdict ${verdict})`);
                     continue;
                 }
                 if (verdict === 'IDLE_CONFIRMED') {

package/src/mesh/mesh-refine-gates.ts

@@ -1200,6 +1200,64 @@ export function collectFastForwardGitlinkPaths(repoRoot: string, baseHead: strin
     });
 }
 
+/**
+ * Collect gitlink resolutions for the *trivial fast-forward* case, so the
+ * gitlink-aware root rebase ({@link rootRebaseResolvingGitlinks}) can drive a
+ * behind>0 rebase whose changed submodule pointer would otherwise make a plain
+ * `git rebase baseHead` abort on the gitlink.
+ *
+ * When base has advanced the SAME submodule as the branch, git's recursive merge
+ * refuses to auto-merge the gitlink even when the two commits are in a strict
+ * ancestor/descendant relationship (a real fast-forward). That is fine for the
+ * patch-equivalence gate (it synthesizes the merged tree), but the sync_base
+ * *rebase* still runs `git rebase baseHead`, which stops on the same gitlink
+ * conflict and aborts → the branch is wrongly blocked. This helper produces the
+ * per-path resolution the root rebase needs so those paths take the gitlink-aware
+ * path instead of the plain rebase.
+ *
+ * Direction rule (kept consistent with the diverged path, which always resolves to
+ * the linear descendant): pick whichever of base/branch commit is the DESCENDANT
+ * of the other and resolve the gitlink to it — the more-advanced commit wins.
+ *   - base ancestor-of branch  → branch is more advanced → resolve to branch-side.
+ *   - branch ancestor-of base  → base is more advanced   → resolve to base-side.
+ *   - neither ancestor (diverged) or ambiguous → excluded (left to the diverged
+ *     converge path / patch-equivalence gate).
+ *
+ * The base-side submodule commit is committed in the base workspace and may be
+ * missing from the worktree's submodule object store; a best-effort local fetch
+ * (identical to {@link convergeDivergedSubmoduleGitlinks}) brings it in so the
+ * ancestry checks and the root rebase's `checkout --detach` can see it.
+ */
+export function collectTrivialFastForwardGitlinkResolutions(
+    worktreeRoot: string,
+    baseRepoRoot: string,
+    baseHead: string,
+    branchHead: string,
+): Array<{ path: string; rebasedCommit: string }> {
+    const resolutions: Array<{ path: string; rebasedCommit: string }> = [];
+    for (const path of readChangedGitlinkPaths(worktreeRoot, baseHead, branchHead)) {
+        const baseCommit = readTreeObject(baseRepoRoot, baseHead, path);
+        const branchCommit = readTreeObject(worktreeRoot, branchHead, path);
+        if (!baseCommit || !branchCommit) continue;
+        const submoduleRepoPath = pathResolve(worktreeRoot, path);
+        // Make the base-side commit available locally (it may only live in base/<path>).
+        ensureSubmoduleCommitLocal(submoduleRepoPath, pathResolve(baseRepoRoot, path), baseCommit);
+        if (baseCommit === branchCommit) {
+            // Identical pointer — no gitlink conflict to resolve; skip.
+            continue;
+        }
+        if (isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit)) {
+            // base ancestor-of branch → branch-side is the descendant (more advanced).
+            resolutions.push({ path, rebasedCommit: branchCommit });
+        } else if (isSubmoduleFastForward(submoduleRepoPath, branchCommit, baseCommit)) {
+            // branch ancestor-of base → base-side is the descendant (more advanced).
+            resolutions.push({ path, rebasedCommit: baseCommit });
+        }
+        // else: diverged / ambiguous → leave to convergeDivergedSubmoduleGitlinks.
+    }
+    return resolutions;
+}
+
 /**
  * Whether both commits exist locally in the submodule repo AND neither is an
  * ancestor of the other — i.e. a genuine sibling divergence off a shared merge

package/src/mesh/mesh-runtime-store.ts

@@ -915,7 +915,12 @@ export class MeshRuntimeStore {
         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 this.transaction(() => {
             this.ensureLegacyQueueMigrated(meshId);
@@ -1070,6 +1075,9 @@ export class MeshRuntimeStore {
             entry.assignedNodeId = nodeId;
             entry.assignedSessionId = sessionId;
             if (providerType) entry.assignedProviderType = providerType;
+            // P1 transcript-authority stamp (write-only for now): lets the
+            // coordinator classify this worker without local provider access.
+            if (opts?.assignedTranscriptProfile) entry.assignedTranscriptProfile = opts.assignedTranscriptProfile;
             entry.dispatchTimestamp = now;
             // REDRIVE-DUP: bump the per-task dispatch nonce on every claim so this dispatch
             // carries a nonce strictly greater than any prior (reclaimed) dispatch of the same