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

package/dist/logging/debug-config.d.ts

@@ -14,6 +14,22 @@ export interface DebugRuntimeConfig {
     traceBufferSize: number;
     traceCategories: string[];
 }
+/**
+ * ALWAYS-ON trace categories. These bypass the `collectDebugTrace` master switch
+ * (and category selection) so they are collected in production daemons where
+ * `--trace` is unset. They exist so mesh completion diagnostics — the FSM-transition
+ * and completion-gate snapshots that explain an early / missing agent:generating_completed
+ * notification — are retrievable via mesh_read_debug (chat_debug_bundle) without asking
+ * an operator to relaunch the daemon with tracing on.
+ *
+ * SAFETY: only add a category here after confirming every record() call site for it
+ * carries a content-free payload (statuses, epochs, timestamps, deltas, lengths, roles,
+ * enum-like reasons — never transcript / prompt / bubble text). Always-on collection makes
+ * such payloads unconditional, so a content-bearing field would leak into the ring buffer
+ * in production.
+ */
+export declare const ALWAYS_ON_TRACE_CATEGORIES: readonly string[];
+export declare function isAlwaysOnTraceCategory(category?: string | null): boolean;
 export declare function resolveDebugRuntimeConfig(options?: DebugRuntimeOptions): DebugRuntimeConfig;
 export declare function setDebugRuntimeConfig(config: DebugRuntimeConfig): void;
 export declare function getDebugRuntimeConfig(): DebugRuntimeConfig;

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

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

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

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

package/dist/mesh/worktree-bootstrap-config.d.ts

@@ -38,6 +38,51 @@ export declare const WORKTREE_BOOTSTRAP_STALE_RUNNING_MS: number;
  * lookup fails — callers must then treat any change as dirty (conservative).
  */
 export declare function getRegisteredSubmodulePaths(workspace: string): Set<string>;
+/**
+ * Read each registered submodule's configured `branch` from `.gitmodules`, keyed
+ * by the submodule's normalized path (matching {@link getRegisteredSubmodulePaths}).
+ *
+ * `.gitmodules` stores `submodule.<name>.path` and (optionally)
+ * `submodule.<name>.branch`; this joins the two on `<name>`. The special branch
+ * value `.` ("track the superproject's branch") is deliberately OMITTED so callers
+ * fall through to remote-HEAD detection instead of treating `.` as a literal branch
+ * name. Returns an empty map when there are no submodules, no `.gitmodules`, or the
+ * lookup fails (conservative — callers then detect or fall back).
+ */
+export declare function getSubmoduleConfiguredBranches(workspace: string): Map<string, string>;
+/** Fallback submodule branch when no configured/detected default can be resolved. */
+export declare const SUBMODULE_DEFAULT_BRANCH_FALLBACK = "main";
+/**
+ * Resolve the default branch a submodule's commits are published to / checked for
+ * reachability against. Generalizes the previously hardcoded `main` so a submodule
+ * whose default branch is `master`/`trunk`/etc. is handled. Priority (each tier
+ * falls through to the next on miss/error):
+ *
+ *   1. `.gitmodules` `submodule.<name>.branch` (via {@link getSubmoduleConfiguredBranches};
+ *      `.` is ignored) — an explicit, local, zero-cost declaration.
+ *   2. the submodule checkout's LOCAL remote HEAD: `git symbolic-ref --short
+ *      refs/remotes/<remote>/HEAD` → strip the `<remote>/` prefix (no network).
+ *   3. the submodule remote's advertised HEAD: `git ls-remote --symref <remote> HEAD`
+ *      → `ref: refs/heads/<branch>` (one network round-trip).
+ *   4. fallback {@link SUBMODULE_DEFAULT_BRANCH_FALLBACK} (`'main'`).
+ *
+ * Because the final fallback is `'main'` and every earlier tier that resolves `'main'`
+ * yields the same string, a repo whose submodules default to `main` (the common case)
+ * produces byte-identical downstream fetch/merge-base/push ref targets — only a
+ * read-only resolution probe is added.
+ */
+export declare function resolveSubmoduleDefaultBranch(opts: {
+    /** The submodule's local checkout — cwd for symbolic-ref / ls-remote. */
+    submoduleRepoPath: string;
+    /** The superproject workspace — for the `.gitmodules` branch lookup (tier 1). */
+    superprojectWorkspace?: string;
+    /** The submodule's path relative to the superproject (key into `.gitmodules`). */
+    submodulePath?: string;
+    /** Remote name (default `origin`). */
+    remote?: string;
+    /** Timeout for the local probe (tier 2); the network probe (tier 3) gets max(this, 30s). */
+    timeoutMs?: number;
+}): Promise<string>;
 export declare function isWorktreeBootstrapStaleRunning(node: {
     worktreeBootstrap?: {
         status?: string;

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

@@ -32,6 +32,32 @@ export declare function extractFinalAssistantSummaryEvidence(messages: ChatMessa
     finalSummary: string;
     transcriptMessageAt?: string;
 };
+/**
+ * EARLYNOTIFY-GATEBYPASS (a)/(b) — the shared turn-finality selector for the completion
+ * final-assistant judgement, so the ~duplicated "which bubble is the turn's final answer"
+ * logic is decided ONE way (UNIFY A-6).
+ *
+ * Returns the message that qualifies as the turn's FINAL assistant bubble, or null when the
+ * transcript does not (yet) prove a turn end. The rule is a NON-EMPTY LATEST user-facing
+ * assistant/model bubble:
+ *   - Scanning from the end, the FIRST user-facing assistant/model bubble encountered IS the
+ *     turn-end candidate. If it is EMPTY (a streaming placeholder / mid-turn narration whose
+ *     text has not landed), the turn is still in flight → return null. Crucially we do NOT walk
+ *     back past that empty bubble to promote an EARLIER assistant narration to "final" (the
+ *     Defect-B walk-back).
+ *   - Trailing activity/internal bubbles (tool/thought/status) are skipped — they are not the
+ *     assistant's user-facing answer.
+ *   - A trailing user-facing USER message (a freshly dispatched task with no reply yet) means the
+ *     assistant did not have the last word — no earlier bubble is promoted here; callers that must
+ *     still reach a prior turn's tail use the timestamp-scoped extractor instead.
+ *
+ * A bare snapshot-idle with an arbitrary non-empty tail therefore does NOT qualify as a turn end;
+ * only a genuine latest-assistant bubble does. Turn-finality signals that live OUTSIDE the
+ * transcript (a committed generating→idle FSM transition, a self-attributing final_summary_json,
+ * or a continuous-idle streak) are enforced by the callers (the CLI completion gate, the reconcile
+ * grace gate) on top of this structural check.
+ */
+export declare function selectFinalAssistantTurnEndMessage(messages: ChatMessage[] | null | undefined): ChatMessage | null;
 export declare const BUILTIN_CHAT_MESSAGE_KINDS: readonly ["standard", "thought", "tool", "terminal", "system"];
 export type BuiltinChatMessageKind = typeof BUILTIN_CHAT_MESSAGE_KINDS[number];
 export type ChatMessageKind = BuiltinChatMessageKind | (string & {});

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

@@ -268,6 +268,13 @@ export declare class CliProviderInstance implements ProviderInstance {
     recordAcknowledgedUserInput(input: InputEnvelope | string): void;
     /** Drop user-input ack entries older than the dedup window so the map can't grow unbounded. */
     private pruneRecentUserInputAcks;
+    /**
+     * Owner token for this session in the antigravity conversation-claim
+     * registry. Derived identically to the dispatcher's read-side token
+     * (workspace + spawn time) so the claims the dispatcher records under this
+     * session are the ones dispose() releases.
+     */
+    private antigravityClaimOwner;
     dispose(): void;
     private completedDebounceTimer;
     private completedDebouncePending;

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

@@ -0,0 +1,28 @@
+/** A claim older than this with no refresh is reclaimable (owner presumed dead). */
+export declare const CLAIM_STALE_MS: number;
+/**
+ * Derive the per-session owner token. Both the dispatcher (from the read input:
+ * workspace + sessionStartedAtMs) and the provider instance (from its
+ * workingDir + startedAt, or its instanceId) call this with the same inputs so
+ * claims and releases line up. Returns '' when there is no stable identity to
+ * key on (e.g. a workspace-less discovery with no spawn time) — the caller then
+ * skips claiming but the exclusion checks still run against existing claims.
+ */
+export declare function antigravityOwnerToken(workspace: string, sessionStartedAtMs: number, instanceId?: string): string;
+/**
+ * Claim `uuid` for `owner`. Succeeds (and refreshes) when the conversation is
+ * unclaimed, already owned by this owner, or held by a stale (abandoned) owner.
+ * Fails when a DIFFERENT live owner holds it. Returns whether `owner` holds the
+ * claim after the call.
+ */
+export declare function claimAntigravityConversation(uuid: string, owner: string, now?: number): boolean;
+/** True when `uuid` is held by a live owner OTHER than `owner`. */
+export declare function isAntigravityConversationClaimedByOther(uuid: string, owner: string, now?: number): boolean;
+/** The live owner of `uuid`, or undefined when unclaimed or stale. */
+export declare function antigravityConversationOwner(uuid: string, now?: number): string | undefined;
+/** Release a single conversation, only if held by `owner` (or `owner` empty). */
+export declare function releaseAntigravityConversation(uuid: string, owner?: string): void;
+/** Release every conversation held by `owner` (called on session shutdown). */
+export declare function releaseAntigravityOwner(owner: string): void;
+/** Test-only: wipe all claims so each test starts from a clean registry. */
+export declare function __resetAntigravityClaimRegistry(): void;

package/dist/providers/native-history/antigravity-cli-transcript.d.ts

@@ -38,6 +38,17 @@
  *      pty parser (which only echoes the user's own input) — assistant
  *      answers appeared lost even though they were on disk.
  *
+ *      Schema-drift resilience: the exact field path (20 → 1/8 for the answer,
+ *      19 → 2/3 for the prompt) is empirically verified against real stores, but
+ *      antigravity may move it in a future build. So when the known path yields
+ *      no text, instead of silently dropping the turn we fall back to a UTF-8
+ *      printable-run scan of the payload (recoverMessageText) that recovers the
+ *      answer/prompt even if the field number drifted — while explicitly
+ *      EXCLUDING the reasoning subtree (20 → 3) so internal reasoning is never
+ *      surfaced as the answer. Only when even that finds nothing beyond
+ *      reasoning/metadata is the step dropped, and a content-free DEBUG
+ *      breadcrumb is logged so a real drift is greppable rather than invisible.
+ *
  * This adapter provides:
  *   - Full coverage from a per-session .db (current format) — preferred.
  *   - Full coverage when a brain transcript exists (legacy authoritative source).

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

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

package/package.json

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

package/src/index.ts

@@ -394,6 +394,8 @@ export {
     getDebugRuntimeConfig,
     resetDebugRuntimeConfig,
     shouldCollectTraceCategory,
+    isAlwaysOnTraceCategory,
+    ALWAYS_ON_TRACE_CATEGORIES,
 } from './logging/debug-config.js';
 export type { DebugRuntimeOptions, DebugRuntimeConfig } from './logging/debug-config.js';
 export {

package/src/logging/debug-config.ts

@@ -20,6 +20,26 @@ export interface DebugRuntimeConfig {
 const NORMAL_TRACE_BUFFER_SIZE = 200
 const DEV_TRACE_BUFFER_SIZE = 1000
 
+/**
+ * ALWAYS-ON trace categories. These bypass the `collectDebugTrace` master switch
+ * (and category selection) so they are collected in production daemons where
+ * `--trace` is unset. They exist so mesh completion diagnostics — the FSM-transition
+ * and completion-gate snapshots that explain an early / missing agent:generating_completed
+ * notification — are retrievable via mesh_read_debug (chat_debug_bundle) without asking
+ * an operator to relaunch the daemon with tracing on.
+ *
+ * SAFETY: only add a category here after confirming every record() call site for it
+ * carries a content-free payload (statuses, epochs, timestamps, deltas, lengths, roles,
+ * enum-like reasons — never transcript / prompt / bubble text). Always-on collection makes
+ * such payloads unconditional, so a content-bearing field would leak into the ring buffer
+ * in production.
+ */
+export const ALWAYS_ON_TRACE_CATEGORIES: readonly string[] = ['completion-gate', 'fsm-transition']
+
+export function isAlwaysOnTraceCategory(category?: string | null): boolean {
+  return !!category && ALWAYS_ON_TRACE_CATEGORIES.includes(category)
+}
+
 const DEFAULT_CONFIG: DebugRuntimeConfig = {
   logLevel: 'info',
   collectDebugTrace: false,
@@ -68,6 +88,11 @@ export function resetDebugRuntimeConfig(): void {
 
 export function shouldCollectTraceCategory(category?: string | null): boolean {
   const config = currentConfig
+  // Always-on categories are collected regardless of the collectDebugTrace master switch
+  // and regardless of any explicit traceCategories selection (they form a superset on top of
+  // whatever the operator requested), so an explicit --trace / --trace-categories run still
+  // includes them with its existing behavior unchanged.
+  if (isAlwaysOnTraceCategory(category)) return true
   if (!config.collectDebugTrace) return false
   if (!category) return true
   if (config.traceCategories.length === 0) return true

package/src/logging/debug-trace.ts

@@ -1,4 +1,4 @@
-import { getDebugRuntimeConfig, shouldCollectTraceCategory } from './debug-config.js'
+import { getDebugRuntimeConfig, isAlwaysOnTraceCategory, shouldCollectTraceCategory } from './debug-config.js'
 
 export type DebugTraceLevel = 'debug' | 'info' | 'warn' | 'error'
 
@@ -80,7 +80,12 @@ export function createDebugTraceStore(options: DebugTraceStoreOptions): DebugTra
 
   return {
     record(event: DebugTraceEvent): DebugTraceEntry | null {
-      if (!options.enabled) return null
+      // The store's `enabled` flag mirrors collectDebugTrace (set by configureDebugTraceStore),
+      // so it is false on a production daemon. Always-on categories must still land in the ring
+      // even then — otherwise the second gate here would swallow what shouldCollectTraceCategory
+      // just admitted. They share the same fixed-capacity buffer, so heavy always-on traffic can
+      // evict older opt-in entries; that is accepted (no separate ring).
+      if (!options.enabled && !isAlwaysOnTraceCategory(event.category)) return null
       const entry = createEntry(event)
       entries.push(entry)
       if (entries.length > capacity) {

package/src/mesh/coordinator-prompt.ts

@@ -577,7 +577,7 @@ function buildRulesSection(coordinatorCliType?: string): string {
 - **Verify via git, not source.** Use \`mesh_git_status\` to confirm side effects. Treat agent summaries as self-reports, not verification.
 - **Limit parallelism.** Start with 1–2 tasks; scale only on success. Never duplicate a session because \`mesh_read_chat\` shows no final message while tool/terminal activity is ongoing. This caps *concurrent* load — it does not mean serialize independent work: when a new, independent request arrives and there is headroom under \`maxParallelTasks\`, dispatch it right away rather than waiting for an in-flight task or a user nudge (read-only diagnosis especially, since it has no merge cost).
 - **Check history first.** Call \`mesh_task_history\` at session start to avoid duplicate work and inform recovery. On failure, read task history before retrying.
-- **Sequence shared-base-moving merges.** Parallel dispatch is encouraged, but merging one worktree can advance another in-flight worktree's base — especially the oss submodule pointer — turning a clean fast-forward into a diverged rebase (patch-equivalence correctly blocks this). Before merging an in-flight worktree while siblings are also in flight, land in an intentional order, re-clone long-running worktrees from the advanced base, or expect to manually rebase + ff-only the laggards; merging an independent fix mid-flight can strand siblings into a rebase.
+- **Sequence shared-base-moving merges.** Parallel dispatch is encouraged, but merging one worktree can advance another in-flight worktree's base — especially a shared submodule pointer — turning a clean fast-forward into a diverged rebase (patch-equivalence correctly blocks this). Before merging an in-flight worktree while siblings are also in flight, land in an intentional order, re-clone long-running worktrees from the advanced base, or expect to manually rebase + ff-only the laggards; merging an independent fix mid-flight can strand siblings into a rebase.
 - **Converge branches.** After worktree tasks: refine/fast-forward, or classify as \`pushed_feature_branch_needs_merge\` / \`blocked_review\` / \`cleanup_candidate\` / \`not_mergeable\`. Clean up with \`mesh_remove_node\`.
 - **Refinery is config-driven.** \`mesh_refine_node\` must run validation from \`.adhdev/refine.{json,yaml,yml}\` or \`repo-mesh.refine.*\`. Heuristics are scaffolding only.
 - **Submodule reachability = publish-needed.** \`submodule_reachability_failed\` → classify as \`blocked_review\`, request user approval to push to submodule main, then rerun \`mesh_refine_node\`.

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

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

package/src/mesh/mesh-fast-forward.ts

@@ -1,6 +1,7 @@
 import type { GitRepoStatus, GitSubmoduleStatus } from '../git/git-types.js';
 import { getGitRepoStatus } from '../git/git-status.js';
 import { GitCommandError, runGit } from '../git/git-executor.js';
+import { resolveSubmoduleDefaultBranch } from './worktree-bootstrap-config.js';
 
 export interface MeshFastForwardNodeArgs {
   nodeId?: string;
@@ -521,31 +522,43 @@ async function resolveSubmodulePushes(
       results.push({ ...base, code: 'submodule_status_incomplete' });
       continue;
     }
-    // Refresh the submodule's origin/main, then require it to be an ancestor of
+    // Generalize the submodule's default branch (F18): '.gitmodules' branch →
+    // local remote HEAD → remote-advertised HEAD → 'main'. On a main-default
+    // submodule this resolves to 'main', keeping every ref below byte-identical.
+    const remoteBranch = await resolveSubmoduleDefaultBranch({
+      submoduleRepoPath: repoPath,
+      superprojectWorkspace: status.repoRoot ?? status.workspace,
+      submodulePath: submodule.path,
+      timeoutMs,
+    });
+    base.remoteBranch = remoteBranch;
+    const remoteRef = `refs/remotes/origin/${remoteBranch}`;
+    const fetchRefspec = `refs/heads/${remoteBranch}:${remoteRef}`;
+    // Refresh the submodule's origin/<branch>, then require it to be an ancestor of
     // the gitlink commit (strict ff-only).
     try {
-      await runGit(repoPath, ['-c', 'protocol.file.allow=always', 'fetch', 'origin', 'refs/heads/main:refs/remotes/origin/main'], { timeoutMs: timeoutMs ?? 30_000 });
+      await runGit(repoPath, ['-c', 'protocol.file.allow=always', 'fetch', 'origin', fetchRefspec], { timeoutMs: timeoutMs ?? 30_000 });
     } catch (error) {
       results.push({ ...base, code: 'submodule_fetch_failed', error: formatGitError(error) });
       continue;
     }
     let alreadyReachable = false;
     try {
-      await runGit(repoPath, ['merge-base', '--is-ancestor', submodule.commit, 'refs/remotes/origin/main'], { timeoutMs: timeoutMs ?? 15_000 });
+      await runGit(repoPath, ['merge-base', '--is-ancestor', submodule.commit, remoteRef], { timeoutMs: timeoutMs ?? 15_000 });
       alreadyReachable = true;
-    } catch { /* not yet on origin/main — candidate for push */ }
+    } catch { /* not yet on origin/<branch> — candidate for push */ }
     if (alreadyReachable) {
       results.push({ ...base, pushed: false, skipped: true, code: 'submodule_already_reachable' });
       continue;
     }
-    // Strict ff-only: origin/main must be an ancestor of the commit we publish.
+    // Strict ff-only: origin/<branch> must be an ancestor of the commit we publish.
     try {
-      await runGit(repoPath, ['merge-base', '--is-ancestor', 'refs/remotes/origin/main', submodule.commit], { timeoutMs: timeoutMs ?? 15_000 });
+      await runGit(repoPath, ['merge-base', '--is-ancestor', remoteRef, submodule.commit], { timeoutMs: timeoutMs ?? 15_000 });
     } catch (error) {
       results.push({ ...base, pushed: false, skipped: false, code: 'submodule_non_fast_forward', error: formatGitError(error) });
       continue;
     }
-    const refspec = `${submodule.commit}:refs/heads/main`;
+    const refspec = `${submodule.commit}:refs/heads/${remoteBranch}`;
     if (!execute) {
       results.push({ ...base, pushed: false, skipped: false, code: 'submodule_push_available', refspec });
       continue;
@@ -553,8 +566,8 @@ async function resolveSubmodulePushes(
     try {
       await runGit(repoPath, ['push', 'origin', refspec], { timeoutMs: timeoutMs ?? 30_000 });
       // Verify reachability after the push.
-      await runGit(repoPath, ['-c', 'protocol.file.allow=always', 'fetch', 'origin', 'refs/heads/main:refs/remotes/origin/main'], { timeoutMs: timeoutMs ?? 30_000 });
-      await runGit(repoPath, ['merge-base', '--is-ancestor', submodule.commit, 'refs/remotes/origin/main'], { timeoutMs: timeoutMs ?? 15_000 });
+      await runGit(repoPath, ['-c', 'protocol.file.allow=always', 'fetch', 'origin', fetchRefspec], { timeoutMs: timeoutMs ?? 30_000 });
+      await runGit(repoPath, ['merge-base', '--is-ancestor', submodule.commit, remoteRef], { timeoutMs: timeoutMs ?? 15_000 });
       results.push({ ...base, pushed: true, skipped: false, code: 'submodule_pushed', refspec });
     } catch (error) {
       results.push({ ...base, pushed: false, skipped: false, code: 'submodule_push_failed', refspec, error: formatGitError(error) });