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

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

@@ -11,6 +11,35 @@ export interface AssignedTaskTerminalEvidence {
     nodeId?: string;
     sessionId: string;
 }
+/**
+ * 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 declare 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>;
 export declare function pollAssignedTaskInTurnProgress(components: DaemonComponents, mesh: {
     id: string;
     nodes?: Array<{

package/dist/mesh/mesh-node-identity.d.ts

@@ -53,6 +53,7 @@ export declare function recordInlineMeshDirectGitTruth(node: any, git: Record<st
     reporterProviderVersions: Record<string, string> | null;
     reporterDaemonBuildVersion: string | null;
     reportedMemberState: MeshReportedMemberState | null;
+    nodeFacts: import('@adhdev/mesh-shared').MeshNodeFacts | null;
 };
 /**
  * Persist the live self-reported platform/arch onto the local meshes.json node
@@ -72,6 +73,7 @@ export declare function persistNodeReporterPlatform(meshSource: 'inline_cache' |
     reporterProviderVersions?: Record<string, string> | null;
     reporterDaemonBuildVersion?: string | null;
     reportedMemberState?: MeshReportedMemberState | null;
+    nodeFacts?: import('@adhdev/mesh-shared').MeshNodeFacts | null;
 }): void;
 export declare function inlineMeshCarriesTransientNodeTruth(inlineMesh: any): boolean;
 export declare function readInlineMeshNodeId(node: any): string;

package/dist/mesh/mesh-refine-gates.d.ts

@@ -504,6 +504,38 @@ type GitlinkTrivialFastForwardEvaluation = {
  * gate.
  */
 export declare function collectFastForwardGitlinkPaths(repoRoot: string, baseHead: string, branchHead: string): string[];
+/**
+ * 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 declare function collectTrivialFastForwardGitlinkResolutions(worktreeRoot: string, baseRepoRoot: string, baseHead: string, branchHead: string): Array<{
+    path: string;
+    rebasedCommit: string;
+}>;
 export type SubmoduleGitlinkConvergeResult = {
     /** True when at least one diverged gitlink submodule was rebased onto its base-side commit. */
     converged: boolean;

package/dist/mesh/mesh-runtime-store.d.ts

@@ -112,6 +112,7 @@ export declare class MeshRuntimeStore {
         providerType?: string;
         providerMaxParallel?: number;
         nodeIsWorktree?: boolean;
+        assignedTranscriptProfile?: MeshWorkQueueEntry['assignedTranscriptProfile'];
     }): MeshWorkQueueEntry | null;
     getQueueStatsByStatus(meshId: string): {
         status: string;

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

@@ -151,6 +151,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;
@@ -331,6 +345,7 @@ export declare function claimNextTask(meshId: string, nodeId: string, sessionId:
     providerType?: string;
     providerMaxParallel?: number;
     nodeIsWorktree?: boolean;
+    assignedTranscriptProfile?: MeshWorkQueueEntry['assignedTranscriptProfile'];
 }): MeshWorkQueueEntry | null;
 export type DependencyFailurePolicy = 'block' | 'cancel';
 /**

package/dist/mesh/node-facts.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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';
+export declare function buildLocalNodeFacts(deps?: {
+    providerVersions?: Record<string, string> | null;
+    machineNickname?: string | null;
+}): MeshNodeFacts;

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

@@ -620,60 +620,33 @@ export declare class CliProviderInstance implements ProviderInstance {
      */
     flushMeshCompletionBeforeCleanup(): boolean;
     /**
-     * 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.
-     *
-     * 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.
-     *
-     * 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.
-     */
-    private tryReconcilePurePtyCompletionForStall;
-    /**
-     * 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;
+     * 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.
+     *
+     * 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.
+     *
+     * 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 tryReconcileTranscriptCompletionForStall;
     /**
      * AUTOAPPROVE-FLAP-RECUR (Fix A+B): how long a busy blip / modal scroll-out may
      * persist before the in-progress settle gate is torn down. For a delegated
@@ -769,9 +742,9 @@ export declare class CliProviderInstance implements ProviderInstance {
      */
     private emitGeneratingCompleted;
     /**
-     * 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

package/dist/providers/transcript-evidence.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 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';
+/** 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 declare function resolveTranscriptAuthorityProfile(provider: TranscriptAuthorityInput | null | undefined): TranscriptAuthorityProfile;

package/dist/repo-mesh-types.d.ts

@@ -793,6 +793,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
@@ -904,6 +912,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
@@ -1070,6 +1086,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;
 }
 export type RepoMeshQueueTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed' | 'cancelled';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "1.0.28-rc.5",
+  "version": "1.0.28-rc.6",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -30,6 +30,8 @@
     "dev": "tsup --watch --no-clean",
     "lint": "eslint \"src/mesh/**/*.ts\"",
     "test": "vitest run",
+    "test:fast": "vitest run --config vitest.fast.config.mts",
+    "test:git": "vitest run --config vitest.git.config.mts",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
@@ -47,8 +49,8 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "1.0.28-rc.5",
-    "@adhdev/session-host-core": "1.0.28-rc.5",
+    "@adhdev/mesh-shared": "1.0.28-rc.6",
+    "@adhdev/session-host-core": "1.0.28-rc.6",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/cli-adapters/cli-state-engine.ts

@@ -15,7 +15,6 @@ import {
 import {
     buildCliScreenSnapshot,
     compactPromptText,
-    isPurePtyTranscriptProvider,
     normalizePromptText,
     promptLikelyVisible,
     type CliChatMessage,
@@ -24,6 +23,7 @@ import {
     type CliTraceEntry,
     type ParsedSession,
 } from './provider-cli-shared.js';
+import { resolveTranscriptAuthorityProfile } from '../providers/transcript-evidence.js';
 import type { CliScriptRunner } from './cli-script-runner.js';
 
 // ─── Types ─────────────────────────────────────────────────────────────────
@@ -375,8 +375,9 @@ export class CliStateEngine {
         // existing PTY-parsed final-assistant idle gate produce a real
         // generating→idle completion edge. Same idle safety as above: applyIdle
         // / finishResponse still own the actual idle transition.
-        const promoteOnTurnStart = this.provider.transcriptAuthority === 'provider'
-            || isPurePtyTranscriptProvider(this.provider);
+        const promoteProfile = resolveTranscriptAuthorityProfile(this.provider);
+        const promoteOnTurnStart = promoteProfile.providerOwnsTranscript
+            || promoteProfile.class === 'pure-pty';
         if (promoteOnTurnStart && this.currentStatus !== 'waiting_approval') {
             this.setStatus('generating', 'turn_started');
             this.callbacks.onStatusChange();

package/src/commands/high-family/mesh-status.ts

@@ -357,6 +357,11 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                             ...(typeof node.reportedDaemonBuildVersion === 'string' && node.reportedDaemonBuildVersion
                                 ? { daemonBuildVersion: node.reportedDaemonBuildVersion }
                                 : {}),
+                            // Opaque pass-through of the versioned facts bundle —
+                            // never rebuild it field-by-field (deploy-lag design §a).
+                            ...(node.nodeFacts && typeof node.nodeFacts === 'object'
+                                ? { nodeFacts: node.nodeFacts }
+                                : {}),
                             providerPriority,
                             // ORCHESTRATION_NODE_SLOTS.md: surface the node's capability
                             // slots so the dashboard slot editor can read them. Only

package/src/commands/router-refine.ts

@@ -36,6 +36,7 @@ import {
     RefineExecFileAsync,
     RefineStageOutcome,
     classifyPatchEquivalenceFailure,
+    collectTrivialFastForwardGitlinkResolutions,
     convergeDivergedSubmoduleGitlinks,
     recordMeshRefineStage,
     resolveRefineryAutoPublishSubmoduleMainCommits,
@@ -626,6 +627,35 @@ export async function refineSyncBaseStage(self: DaemonCommandRouter, ctx: Refine
                 }
             } catch { /* fail-open: on gate error, fall through to the rebase */ }
 
+            // TRIVIAL-FF GITLINK: the diverged path above only fills gitlinkResolutions
+            // when base and branch advanced the SAME submodule to NON-ff (sibling) commits.
+            // When the changed gitlink is instead a strict fast-forward (base advanced the
+            // submodule to an ancestor/descendant of the branch-side commit — the common
+            // case when a sibling branch already merged its oss bump), the pre-rebase gate
+            // reports NO submodule_conflict, so gitlinkResolutions stays empty and the plain
+            // `git rebase baseHead` below runs. That plain rebase still hits the same gitlink
+            // and aborts ("Recursive merging with submodules currently only supports trivial
+            // cases"), wrongly blocking the branch. So when behind>0 and any changed gitlink
+            // remains (and the diverged path did not already resolve them), collect the
+            // trivial-ff resolutions and take the gitlink-aware root rebase too. Direction is
+            // the same as the diverged rule: resolve to the more-advanced (descendant) commit.
+            if (gitlinkResolutions.length === 0) {
+                try {
+                    const ffResolutions = collectTrivialFastForwardGitlinkResolutions(
+                        node.workspace, repoRoot, baseHead, branchHead,
+                    );
+                    if (ffResolutions.length > 0) {
+                        gitlinkResolutions = ffResolutions;
+                        recordMeshRefineStage(refineStages, 'submodule_gitlink_converge', 'passed', syncStarted, {
+                            reason: 'submodule_trivial_ff_gitlink_aware_rebase',
+                            gitlinks: ffResolutions.map(r => ({ path: r.path, rebasedCommit: r.rebasedCommit })),
+                        });
+                        LOG.info('Mesh', `[Refinery] Trivial fast-forward submodule gitlink(s) for node ${node.id} — using gitlink-aware rebase: `
+                            + ffResolutions.map(r => `${r.path}→${r.rebasedCommit.slice(0, 12)}`).join(', '));
+                    }
+                } catch { /* fail-open: on collection error, fall through to the plain rebase */ }
+            }
+
             // behind>0: strictly-behind OR diverged. Rebase the branch onto the pinned
             // baseHead. A conflict aborts and terminates blocked_review (retryable=false —
             // a real content conflict needs human resolution, not a base-movement retry).

package/src/config/mesh-config.ts

@@ -651,6 +651,8 @@ export function updateNode(
          *  Slots are NOT carried — they are coordinator-owned config
          *  (REMOTE-NODE-SLOTS-COORDINATOR-LOCAL fix). */
         reportedMemberState?: MeshReportedMemberState;
+        /** Versioned runtime-facts bundle — whole-object replace, opaque. */
+        nodeFacts?: import('@adhdev/mesh-shared').MeshNodeFacts;
     },
 ): LocalMeshNodeEntry | undefined {
     const config = loadMeshConfig();
@@ -676,6 +678,11 @@ export function updateNode(
         // fields). normalizeReportedMemberState upstream guarantees a clean shape.
         node.reportedMemberState = opts.reportedMemberState;
     }
+    if (opts.nodeFacts) {
+        // Versioned runtime-facts bundle — whole-object replace, OPAQUE (unknown
+        // future fields persist untouched; deploy-lag design §a).
+        node.nodeFacts = opts.nodeFacts;
+    }
     if (opts.policy) node.policy = { ...node.policy, ...opts.policy };
     if (Object.prototype.hasOwnProperty.call(opts, 'capabilities')) {
         // Explicit replace: normalize (trim/dedup/drop-empties); an empty result

package/src/git/git-commands.ts

@@ -4,6 +4,7 @@ import { getGitDiffSummary, getGitFileDiff } from './git-diff.js';
 import { GitCommandError, isPathInside, resolveGitRepository, runGit } from './git-executor.js';
 import { createGitSnapshotStore } from './git-snapshot-store.js';
 import { getGitRepoStatus } from './git-status.js';
+import { buildLocalNodeFacts } from '../mesh/node-facts.js';
 import { loadConfig } from '../config/config.js';
 import type {
   GitCommandName,
@@ -133,7 +134,7 @@ type GitCommandSuccess =
   // (REMOTE-NODE-SLOTS-COORDINATOR-LOCAL fix). The legacy flat
   // reporterProviderVersions/reporterDaemonBuildVersion fields are ALSO emitted for
   // back-compat during a mixed-version-mesh rollout.
-  | { success: true; status: GitRepoStatus; reporterPlatform?: string; reporterArch?: string; reporterMachineNickname?: string; reporterProviderVersions?: Record<string, string>; reporterDaemonBuildVersion?: string; reporterMemberState?: { providerVersions?: Record<string, string>; daemonBuildVersion?: string; lastReportedAt?: number } }
+  | { success: true; status: GitRepoStatus; reporterPlatform?: string; reporterArch?: string; reporterMachineNickname?: string; reporterProviderVersions?: Record<string, string>; reporterDaemonBuildVersion?: string; reporterMemberState?: { providerVersions?: Record<string, string>; daemonBuildVersion?: string; lastReportedAt?: number }; reporterNodeFacts?: import('@adhdev/mesh-shared').MeshNodeFacts }
   | { success: true; diffSummary: GitDiffSummary }
   | { success: true; diff: GitFileDiff }
   | { success: true; snapshot: GitSnapshot }
@@ -382,6 +383,14 @@ export async function handleGitCommand(
               lastReportedAt: Date.now(),
             }
           : undefined;
+      // Versioned facts bundle (deploy-lag visibility design §a): built by the
+      // SAME buildLocalNodeFacts the self-node stamp uses, relayed opaquely —
+      // never rebuild it field-by-field downstream. Legacy flat fields and
+      // reporterMemberState ride alongside for mixed-version meshes.
+      const reporterNodeFacts = buildLocalNodeFacts({
+        providerVersions: reporterProviderVersions ?? null,
+        machineNickname: reporterMachineNickname ?? null,
+      });
       return {
         success: true,
         status,
@@ -391,6 +400,7 @@ export async function handleGitCommand(
         ...(reporterProviderVersions ? { reporterProviderVersions } : {}),
         ...(reporterDaemonBuildVersion ? { reporterDaemonBuildVersion } : {}),
         ...(reporterMemberState ? { reporterMemberState } : {}),
+        reporterNodeFacts,
       };
     }