@adhdev/daemon-core 0.9.82-rc.461 → 0.9.82-rc.462

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

@@ -52,8 +52,32 @@ export interface PendingEventEmitHint {
     /** coordinatorRunId to fold into the derived identity when the event lacks one. */
     coordinatorRunId?: string;
 }
-/** Observability counters for the accept-and-warn rollout. Read by tests and (later,
- *  B4) surfaced in mesh_status. Process-lifetime totals — never reset in production. */
+/**
+ * T6 (B3c) enforce switch. When ON, the drain path stops passing an unversioned
+ * (v1) or a validation-failing v2 event through to the coordinator — it QUARANTINES
+ * it instead (excluded from the delivered batch + WARN + counter), and unicast
+ * routing is the only delivery path (there is no v1 broadcast fallback). Off (the
+ * default) preserves the accept-and-warn rollout behaviour exactly.
+ *
+ * Per the rollout plan (§1 decision 4): enforce is `MESH_PROTOCOL_V2_ENFORCE` (env)
+ * — its activation is a deliberate operational step taken ONLY after daemonBuilds
+ * confirms every node emits v2 (§배포 게이트 1 / risk §4). So the code default is
+ * OFF; flipping the env back to accept mode is a pure-env rollback (no code change,
+ * no data migration — the schema is additive). Read at call time so a test /
+ * operator can toggle it without a restart.
+ *
+ * Quarantine (not drop) keeps the loss-free invariant. The DESTRUCTIVE drain has
+ * already consumed the event from its store by the time routing runs, so "held
+ * back" here means: excluded from the delivered batch AND mirrored into the mesh
+ * ledger as a recoverable `event_held` entry (the same recovery channel the
+ * pending-trim path uses). It is observable via the counters + the ledger, so an
+ * operator can requeue it after fixing the producer. The non-destructive PEEK path
+ * (countMetrics=false) merely omits the event from the returned list — it never
+ * consumed it and must not ledger-record on every status poll.
+ */
+export declare function isMeshProtocolV2EnforceEnabled(): boolean;
+/** Observability counters for the v2 drain path. Read by tests and surfaced in
+ *  mesh_status (B4/T6). Process-lifetime totals — never reset in production. */
 declare const meshV2DrainCounters: {
     /** v2 events that passed validation and unicast/broadcast routing → delivered. */
     v2Delivered: number;
@@ -70,6 +94,14 @@ declare const meshV2DrainCounters: {
     v2ReattributedToDrainer: number;
     /** v1 (unversioned) events passed through as broadcast (rollout baseline). */
     v1BroadcastAccepted: number;
+    /** T6 enforce: v2 events that FAILED validation and were QUARANTINED (held back
+     *  from delivery, not dropped). Non-zero here means a producer is still emitting a
+     *  malformed envelope after enforce was turned on. */
+    v2ValidationFailedQuarantined: number;
+    /** T6 enforce: v1 (unversioned) events QUARANTINED because no v2 envelope could be
+     *  derived at emit time. Non-zero here means a producer path still emits v1 after
+     *  enforce — it should reach 0 once every node is on a v2-stamping build. */
+    v1UnversionedQuarantined: number;
 };
 /** Test/observability accessor for the v2 drain counters (snapshot copy). */
 export declare function getMeshV2DrainCounters(): Readonly<typeof meshV2DrainCounters>;

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

@@ -1,6 +1,6 @@
 export type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
-export { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, serializeV2EnvelopeToWire, readV2EnvelopeFromWire, } from './mesh-events-pending.js';
+export { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, serializeV2EnvelopeToWire, readV2EnvelopeFromWire, getMeshV2DrainCounters, isMeshProtocolV2EnforceEnabled, } from './mesh-events-pending.js';
 export { reconcileDirectDispatchCompletionFromTranscript, } from './mesh-events-stale.js';
-export { setupMeshReconcileLoop, runMeshReconcileTick, resolveCoordinatorDrainDeliverability, shouldHoldPendingDrainForBusyLocalCoordinator, } from './mesh-reconcile-loop.js';
+export { setupMeshReconcileLoop, runMeshReconcileTick, resolveCoordinatorDrainDeliverability, shouldHoldPendingDrainForBusyLocalCoordinator, getMeshV2BackstopCounters, } from './mesh-reconcile-loop.js';
 export type { MeshQueueTriggerResult } from './mesh-events-coordinator.js';
 export { tryAssignQueueTask, isSessionActivelyGenerating, triggerMeshQueue, handleMeshForwardEvent, setupMeshEventForwarding, isMeshCoordinatorEvent, __resetIdleAutoFastForwardForTests, __resetMeshWorkspaceCacheForTests, } from './mesh-events-coordinator.js';

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

@@ -1,4 +1,16 @@
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
+declare const meshV2BackstopCounters: {
+    /** PHASE-4 transcript synthesis actually reconciled a missing completion. */
+    phase4SynthesisFired: number;
+    /** Acked-hold transcript fast-track promoted a synth ahead of the death deadline. */
+    ackedHoldFastTrackFired: number;
+    /** Acked-hold death-deadline backstop released a held synth (the 8-min net). */
+    ackedHoldDeathDeadlineFired: number;
+};
+/** Test/observability accessor for the v2 last-resort backstop counters (snapshot). */
+export declare function getMeshV2BackstopCounters(): Readonly<typeof meshV2BackstopCounters>;
+/** Test helper: zero the backstop counters so a case starts from a clean slate. */
+export declare function __resetMeshV2BackstopCountersForTests(): void;
 export declare function __resetReconcileInFlightSynthDebounceForTests(): void;
 /**
  * DRAIN-WITHOUT-INJECT guard. Classify, for a mesh on THIS daemon, whether a

package/dist/providers/approval-utils.d.ts

@@ -1,4 +1,5 @@
 import type { ProviderModule } from './contracts.js';
+export declare function normalizeApprovalLabel(value: string): string;
 /**
  * True when any of the given button labels reads as a decline/negative option
  * (No / Deny / Cancel / Skip / …). Used as the second half of an approval-modal

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

@@ -743,6 +743,37 @@ export interface RepoMeshStatus {
      * Omitted when nothing was drained. Mirrors the MCP tool's meshProtocolMetrics.
      */
     meshProtocolMetrics?: MeshProtocolMetrics;
+    /**
+     * T6 (B3c): live process-lifetime mesh-protocol-v2 enforce counters from THIS
+     * daemon — the enforce flag state, drain-routing tallies (deliver / route-away /
+     * dedup / quarantine), and the last-resort backstop fire counts (PHASE-4 synth,
+     * acked-hold fast-track / death-deadline). Diagnostic-only and never cached (a
+     * live snapshot). Under enforce, non-zero quarantine or backstop counts are the
+     * rollout-health signal (target 0). Omitted when unavailable.
+     */
+    meshProtocolV2Counters?: MeshProtocolV2Counters;
+}
+/** T6 (B3c) live v2 enforce/observability counters (see RepoMeshStatus.meshProtocolV2Counters). */
+export interface MeshProtocolV2Counters {
+    /** True when MESH_PROTOCOL_V2_ENFORCE is active on this daemon. */
+    enforce: boolean;
+    /** Drain-path routing tallies (accept + enforce). Process-lifetime totals. */
+    drain: {
+        v2Delivered: number;
+        v2RoutedAway: number;
+        v2DedupSkipped: number;
+        v2ValidationFailedAccepted: number;
+        v2ReattributedToDrainer: number;
+        v1BroadcastAccepted: number;
+        v2ValidationFailedQuarantined: number;
+        v1UnversionedQuarantined: number;
+    };
+    /** Last-resort backstop fire counts. Target 0 under a healthy v2 contract. */
+    backstop: {
+        phase4SynthesisFired: number;
+        ackedHoldFastTrackFired: number;
+        ackedHoldDeathDeadlineFired: number;
+    };
 }
 /** One provider's version skew across mesh nodes (see RepoMeshStatus.providerVersionSkew). */
 export interface MeshProviderVersionSkew {

package/package.json

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

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

@@ -12,6 +12,9 @@ import {
     drainPendingMeshCoordinatorEvents,
     shouldHoldPendingDrainForBusyLocalCoordinator,
     resolveCoordinatorDrainDeliverability,
+    getMeshV2DrainCounters,
+    getMeshV2BackstopCounters,
+    isMeshProtocolV2EnforceEnabled,
 } from '../../mesh/mesh-events.js';
 import { normalizeInteractivePromptResponse } from '../../providers/types/interactive-prompt.js';
 import type { HighFamilyContext, HighFamilyHandler } from './types.js';
@@ -66,11 +69,21 @@ export const meshEventsHandlers: Record<string, HighFamilyHandler> = {
             return { success: true, events: [], heldForBusyLocalCoordinator: true, hasLiveCliCoordinator };
         }
         const events = drainPendingMeshCoordinatorEvents(meshId || undefined, coordinatorDaemonId);
+        // T6 (B3c): ride the live v2 enforce/backstop counters on the drain response so a
+        // pure stdio MCP coordinator (which reads its inbox via this IPC call, not the
+        // daemon-core mesh_status command) sees the same enforce state + quarantine /
+        // last-resort-backstop tallies. Process-lifetime snapshot; the counters were just
+        // updated by the drain above. Additive — omitting it keeps version-skewed pullers safe.
+        const meshProtocolV2Counters = {
+            enforce: isMeshProtocolV2EnforceEnabled(),
+            drain: { ...getMeshV2DrainCounters() },
+            backstop: { ...getMeshV2BackstopCounters() },
+        };
         // SELF-COORDINATOR INBOX LEVEL-DRAIN: when the busy local coordinator drained its OWN
         // inbox (selfCoordinatorInboxRead), tell the puller these events were surfaced through
         // the caller's tool result — it must NOT re-forward them into the (busy) PTY (that is the
         // lossy path). Absent the flag, delivery is unchanged (reconcile-owned PTY / remote pull).
-        return { success: true, events, hasLiveCliCoordinator, ...(selfCoordinatorInboxRead ? { surfacedForSelfCoordinator: true } : {}) };
+        return { success: true, events, hasLiveCliCoordinator, meshProtocolV2Counters, ...(selfCoordinatorInboxRead ? { surfacedForSelfCoordinator: true } : {}) };
     },
 
     interactive_prompt_response: async (ctx: HighFamilyContext, args: any) => {

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

@@ -19,7 +19,13 @@ import {
     normalizeMeshNodeId,
     daemonIdsEquivalent,
 } from '@adhdev/mesh-shared';
-import { getPendingMeshCoordinatorEvents } from '../../mesh/mesh-events.js';
+import {
+    getPendingMeshCoordinatorEvents,
+    getMeshV2DrainCounters,
+    getMeshV2BackstopCounters,
+    isMeshProtocolV2EnforceEnabled,
+} from '../../mesh/mesh-events.js';
+import type { MeshProtocolV2Counters } from '../../repo-mesh-types.js';
 import { getRecentUnroutableDeliveries } from '../../mesh/mesh-routing.js';
 import { normalizeMeshDaemonRole, resolveMeshHostStatus } from '../../mesh/mesh-host-ownership.js';
 import { buildPreviewFreshness } from '../../mesh/preview-freshness.js';
@@ -592,6 +598,15 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                     // that a worker completion was lost (envelope present, mesh unresolved) instead
                     // of it vanishing silently. Diagnostic-only — never cached (see omit below).
                     const unroutableDeliveries = getRecentUnroutableDeliveries();
+                    // T6 (B3c): live enforce/observability counters from this daemon. A
+                    // process-lifetime snapshot (never cached — like unroutableDeliveries)
+                    // so an operator/coordinator can read enforce state, quarantine tallies,
+                    // and last-resort backstop fires straight from the aggregate status.
+                    const meshProtocolV2Counters: MeshProtocolV2Counters = {
+                        enforce: isMeshProtocolV2EnforceEnabled(),
+                        drain: { ...getMeshV2DrainCounters() },
+                        backstop: { ...getMeshV2BackstopCounters() },
+                    };
                     const previewFreshness = (() => {
                         const localRepoRoot = nodeStatuses
                             .map((node: any) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace))
@@ -707,6 +722,7 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                         ...(historicalSessions ? { historicalSessions } : {}),
                         ...(pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {}),
                         ...(unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {}),
+                        meshProtocolV2Counters,
                         activeRefineJobs: Array.from(ctx.runningRefineJobs.values())
                             .filter(job => job.meshId === meshId)
                             .map(job => ({
@@ -718,7 +734,7 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                                 targetCoordinatorDaemonId: job.targetCoordinatorDaemonId,
                             })),
                     };
-                    const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, ...cacheableStatusResult } = statusResult as any;
+                    const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, meshProtocolV2Counters: _meshProtocolV2Counters, ...cacheableStatusResult } = statusResult as any;
                     // Verbose carries full mission goals; never store it in the shared
                     // (compact) aggregate cache or a later compact poll would return the
                     // heavy goals from cache. Return it without caching.
@@ -729,6 +745,7 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                         ...rememberedStatus,
                         ...(pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {}),
                         ...(unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {}),
+                        meshProtocolV2Counters,
                     };
                     logRepoMeshStatusDebug('return_live', {
                         meshId,

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

@@ -134,8 +134,68 @@ function normalizeCoordinatorDaemonIds(
 //      SAME machine as the drainer (a coordinatorRunId change from a restart
 //      orphaned it): it is delivered to the current coordinator on that daemon.
 
-/** Observability counters for the accept-and-warn rollout. Read by tests and (later,
- *  B4) surfaced in mesh_status. Process-lifetime totals — never reset in production. */
+/**
+ * T6 (B3c) enforce switch. When ON, the drain path stops passing an unversioned
+ * (v1) or a validation-failing v2 event through to the coordinator — it QUARANTINES
+ * it instead (excluded from the delivered batch + WARN + counter), and unicast
+ * routing is the only delivery path (there is no v1 broadcast fallback). Off (the
+ * default) preserves the accept-and-warn rollout behaviour exactly.
+ *
+ * Per the rollout plan (§1 decision 4): enforce is `MESH_PROTOCOL_V2_ENFORCE` (env)
+ * — its activation is a deliberate operational step taken ONLY after daemonBuilds
+ * confirms every node emits v2 (§배포 게이트 1 / risk §4). So the code default is
+ * OFF; flipping the env back to accept mode is a pure-env rollback (no code change,
+ * no data migration — the schema is additive). Read at call time so a test /
+ * operator can toggle it without a restart.
+ *
+ * Quarantine (not drop) keeps the loss-free invariant. The DESTRUCTIVE drain has
+ * already consumed the event from its store by the time routing runs, so "held
+ * back" here means: excluded from the delivered batch AND mirrored into the mesh
+ * ledger as a recoverable `event_held` entry (the same recovery channel the
+ * pending-trim path uses). It is observable via the counters + the ledger, so an
+ * operator can requeue it after fixing the producer. The non-destructive PEEK path
+ * (countMetrics=false) merely omits the event from the returned list — it never
+ * consumed it and must not ledger-record on every status poll.
+ */
+export function isMeshProtocolV2EnforceEnabled(): boolean {
+    const raw = readNonEmptyString(process.env.MESH_PROTOCOL_V2_ENFORCE);
+    if (!raw) return false;
+    const v = raw.trim().toLowerCase();
+    return v === '1' || v === 'true' || v === 'on' || v === 'yes';
+}
+
+/**
+ * Record a v2-enforce-quarantined event into the mesh ledger as recoverable, so a
+ * destructively-drained event held back by enforce is auditable and requeue-able
+ * (loss-free invariant). Mirrors the pending-trim `event_held` shape. Best-effort:
+ * a ledger write failure must not break the drain. Called ONLY on the destructive
+ * drain path (the peek path never consumed the event, so nothing to recover).
+ */
+function ledgerRecordQuarantinedEvent(event: PendingMeshCoordinatorEvent, reason: string): void {
+    try {
+        const finalSummary = readMeshCompletionSummary(event.metadataEvent || {});
+        appendLedgerEntry(event.meshId, {
+            kind: 'event_held',
+            ...(event.nodeId ? { nodeId: event.nodeId } : {}),
+            payload: {
+                event: event.event,
+                reason,
+                recoverable: true,
+                nodeLabel: event.nodeLabel,
+                ...(event.workspace ? { workspace: event.workspace } : {}),
+                targetCoordinatorDaemonId: event.targetCoordinatorDaemonId ?? null,
+                ...(readNonEmptyString(event.eventId) ? { eventId: event.eventId } : {}),
+                queuedAt: event.queuedAt,
+                ...(finalSummary ? { finalSummary } : {}),
+            },
+        });
+    } catch (e: any) {
+        LOG.warn('MeshEventsV2', `Failed to ledger-record v2-quarantined ${event.event} for mesh ${event.meshId}: ${e?.message || e}`);
+    }
+}
+
+/** Observability counters for the v2 drain path. Read by tests and surfaced in
+ *  mesh_status (B4/T6). Process-lifetime totals — never reset in production. */
 const meshV2DrainCounters = {
     /** v2 events that passed validation and unicast/broadcast routing → delivered. */
     v2Delivered: 0,
@@ -152,6 +212,14 @@ const meshV2DrainCounters = {
     v2ReattributedToDrainer: 0,
     /** v1 (unversioned) events passed through as broadcast (rollout baseline). */
     v1BroadcastAccepted: 0,
+    /** T6 enforce: v2 events that FAILED validation and were QUARANTINED (held back
+     *  from delivery, not dropped). Non-zero here means a producer is still emitting a
+     *  malformed envelope after enforce was turned on. */
+    v2ValidationFailedQuarantined: 0,
+    /** T6 enforce: v1 (unversioned) events QUARANTINED because no v2 envelope could be
+     *  derived at emit time. Non-zero here means a producer path still emits v1 after
+     *  enforce — it should reach 0 once every node is on a v2-stamping build. */
+    v1UnversionedQuarantined: 0,
 };
 
 /** Test/observability accessor for the v2 drain counters (snapshot copy). */
@@ -271,23 +339,49 @@ function routeV2EventsForDrainer(
     },
 ): PendingMeshCoordinatorEvent[] {
     if (!drainer) return events;
+    // Read the enforce flag ONCE per drain so the whole batch is classified under a
+    // single, consistent policy (a mid-batch env flip cannot split one drain).
+    const enforce = isMeshProtocolV2EnforceEnabled();
     const bump = (k: keyof typeof meshV2DrainCounters) => { if (ctx.countMetrics) meshV2DrainCounters[k]++; };
     const kept: PendingMeshCoordinatorEvent[] = [];
     for (const event of events) {
         if (!isV2Event(event)) {
-            // v1 / unversioned event → broadcast during rollout (existing policy).
+            // v1 / unversioned event. ACCEPT MODE: broadcast during rollout (existing
+            // policy). ENFORCE MODE: quarantine — an unversioned event has no scope, so
+            // there is no safe unicast target; hold it back (not delivered) and mirror
+            // it to the ledger as recoverable, with a one-shot WARN + counter.
+            if (enforce) {
+                bump('v1UnversionedQuarantined');
+                if (ctx.countMetrics) ledgerRecordQuarantinedEvent(event, 'v2_enforce_unversioned_quarantined');
+                warnV2Once(
+                    `${event.meshId}::${event.eventId ?? event.event}::v1-quarantined`,
+                    `v2 ENFORCE: unversioned ${event.event} on mesh ${event.meshId} QUARANTINED (no v2 envelope — held back, not delivered; ledger-recorded recoverable). A producer path still emits v1.`,
+                );
+                continue;
+            }
             bump('v1BroadcastAccepted');
             kept.push(event);
             continue;
         }
 
         // Validate the v2 envelope. ACCEPT MODE: a validation failure does NOT drop
-        // the event — it passes through with a one-shot WARN + counter. (T6 enforce
-        // mode is where this becomes a quarantine.)
+        // the event — it passes through with a one-shot WARN + counter. ENFORCE MODE:
+        // a validation failure is QUARANTINED (held back, not delivered) — the malformed
+        // envelope carries no trustworthy scope/target, so delivering it risks a
+        // cross-surface. It is ledger-recorded recoverable on the destructive path.
         let validated: PendingMeshCoordinatorEventV2;
         try {
             validated = assertPendingMeshCoordinatorEventV2(event);
         } catch (e: any) {
+            if (enforce) {
+                bump('v2ValidationFailedQuarantined');
+                if (ctx.countMetrics) ledgerRecordQuarantinedEvent(event, 'v2_enforce_validation_failed_quarantined');
+                warnV2Once(
+                    `${event.meshId}::${event.eventId ?? event.event}::invalid-quarantined`,
+                    `v2 ENFORCE: envelope validation failed for ${event.event} on mesh ${event.meshId} — QUARANTINED (held back, not delivered; ledger-recorded recoverable): ${e?.message || e}`,
+                );
+                continue;
+            }
             bump('v2ValidationFailedAccepted');
             warnV2Once(
                 `${event.meshId}::${event.eventId ?? event.event}::invalid`,

package/src/mesh/mesh-events.ts

@@ -13,6 +13,8 @@ export {
     clearPendingMeshCoordinatorEvents,
     serializeV2EnvelopeToWire,
     readV2EnvelopeFromWire,
+    getMeshV2DrainCounters,
+    isMeshProtocolV2EnforceEnabled,
 } from './mesh-events-pending.js';
 
 export {
@@ -24,6 +26,7 @@ export {
     runMeshReconcileTick,
     resolveCoordinatorDrainDeliverability,
     shouldHoldPendingDrainForBusyLocalCoordinator,
+    getMeshV2BackstopCounters,
 } from './mesh-reconcile-loop.js';
 
 export type { MeshQueueTriggerResult } from './mesh-events-coordinator.js';

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

@@ -258,6 +258,59 @@ const inFlightAckedHoldState = new Map<string, AckedHoldState>();
 // A restart resets this set, so the first touch of each mesh reloads from disk.
 const rehydratedHoldMeshes = new Set<string>();
 
+// ─── T6 (B3c): PHASE-4 synthesis + acked-hold fast-track demoted to last-resort ──
+//
+// Under mesh-protocol-v2 enforce, the completion contract is explicit: a worker's
+// terminal emit is a v2 unicast event drained straight to the coordinator. The
+// PHASE-4 transcript-synthesis backstop and the acked-hold fast-track exist to
+// paper over a LOST emit — they should NEVER fire once v2 delivery is healthy. So
+// their firing is now a demoted last-resort signal: every fire bumps a counter, and
+// under enforce a fire additionally emits a WARN naming it a v2-contract violation
+// (a real emit was expected but never arrived). Target = 0 fires in steady state.
+//
+// The code is NOT removed — it stays as the correctness net for a genuinely lost
+// emit (rollout plan §B3c: "코드 삭제는 하지 않고 관측 후 다음 사이클에 판단"). Process-
+// lifetime totals; read by tests + surfaced in mesh_status.
+const meshV2BackstopCounters = {
+    /** PHASE-4 transcript synthesis actually reconciled a missing completion. */
+    phase4SynthesisFired: 0,
+    /** Acked-hold transcript fast-track promoted a synth ahead of the death deadline. */
+    ackedHoldFastTrackFired: 0,
+    /** Acked-hold death-deadline backstop released a held synth (the 8-min net). */
+    ackedHoldDeathDeadlineFired: 0,
+};
+
+/** Test/observability accessor for the v2 last-resort backstop counters (snapshot). */
+export function getMeshV2BackstopCounters(): Readonly<typeof meshV2BackstopCounters> {
+    return { ...meshV2BackstopCounters };
+}
+
+/** Test helper: zero the backstop counters so a case starts from a clean slate. */
+export function __resetMeshV2BackstopCountersForTests(): void {
+    for (const k of Object.keys(meshV2BackstopCounters) as Array<keyof typeof meshV2BackstopCounters>) {
+        meshV2BackstopCounters[k] = 0;
+    }
+}
+
+/** Enforce switch mirror (see isMeshProtocolV2EnforceEnabled in mesh-events-pending);
+ *  re-read here (not imported) to keep the reconcile loop free of a cross-file coupling
+ *  and to read env at fire time. Same truthy vocabulary. */
+function meshProtocolV2EnforceOn(): boolean {
+    const raw = process.env.MESH_PROTOCOL_V2_ENFORCE;
+    if (typeof raw !== 'string') return false;
+    const v = raw.trim().toLowerCase();
+    return v === '1' || v === 'true' || v === 'on' || v === 'yes';
+}
+
+/** Bump a backstop counter and, under enforce, WARN that a last-resort net fired —
+ *  which under a healthy v2 contract should not happen (the real emit was lost). */
+function recordBackstopFire(kind: keyof typeof meshV2BackstopCounters, detail: string): void {
+    meshV2BackstopCounters[kind]++;
+    if (meshProtocolV2EnforceOn()) {
+        LOG.warn('MeshReconcileV2', `v2 ENFORCE last-resort backstop fired (${kind}): ${detail}. Under a healthy v2 completion contract this should be 0 — a worker's real terminal emit was lost/late.`);
+    }
+}
+
 function inFlightSynthKey(meshId: string, taskId: string): string {
     return `${meshId}::${taskId}`;
 }
@@ -2011,6 +2064,12 @@ async function reconcileUnterminatedDirectDispatches(
 
         const synthKey = inFlightSynthKey(mesh.id, taskId);
         const isAcked = dispatch.status === 'acked';
+        // T6: which last-resort backstop (if any) drove this synth. Set when the
+        // acked-hold fast-track / death-deadline promotes the synth; the counter is
+        // bumped only if the synth actually COMMITS (result.reconciled), so a
+        // deferred/re-probed-away synth is not miscounted. A never-acked dispatch
+        // that reaches the commit is a plain PHASE-4 transcript synthesis.
+        let backstopKind: keyof ReturnType<typeof getMeshV2BackstopCounters> | undefined;
 
         // R4f: read the worker session. A FAILED read (transport error / success:false / no payload)
         // is no longer silently swallowed for an acked task — it is the liveness side of the
@@ -2130,6 +2189,7 @@ async function reconcileUnterminatedDirectDispatches(
                 const idleHeldMs = nowMs - idleSinceMs;
                 if (idleHeldMs >= fastTrackGraceMs) {
                     fastTrackReady = true;
+                    backstopKind = 'ackedHoldFastTrackFired';
                     LOG.info('MeshReconcile', `Acked-hold transcript fast-track: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read idle WITH a final assistant message for ${Math.round(idleHeldMs / 1000)}s continuous (grace ${Math.round(fastTrackGraceMs / 1000)}s) — promoting the synth ahead of the ${Math.round(deathDeadlineMs / 1000)}s death backstop; the worker's real emit was lost/late and a later one no-ops idempotently.`);
                 }
             } else if (holdState?.transcriptIdleSinceMs !== undefined) {
@@ -2144,6 +2204,7 @@ async function reconcileUnterminatedDirectDispatches(
                 continue;
             }
             if (!fastTrackReady) {
+                backstopKind = 'ackedHoldDeathDeadlineFired';
                 LOG.warn('MeshReconcile', `Acked-hold death deadline reached: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) still idle ${Math.round(sinceAckMs / 1000)}s after the ack (deadline ${Math.round(deathDeadlineMs / 1000)}s) — synthesizing the missing completion as a notification-loss net (a real emit, if it ever lands, no-ops idempotently).`);
             }
         }
@@ -2221,6 +2282,11 @@ async function reconcileUnterminatedDirectDispatches(
                 source: 'daemon_reconcile_transcript_completion',
             });
             if (result.reconciled) {
+                // T6: this synth actually committed → count the last-resort backstop fire.
+                // An acked hold routes to the fast-track / death-deadline kind captured
+                // above; a never-acked dispatch is a plain PHASE-4 transcript synthesis.
+                // Under enforce, recordBackstopFire additionally WARNs (target = 0 fires).
+                recordBackstopFire(backstopKind ?? 'phase4SynthesisFired', `task ${taskId} on node ${nodeId} (mesh ${mesh.id}), kind=${result.kind}`);
                 LOG.info('MeshReconcile', `Synthesized missing completion (${result.kind}) for task ${taskId} on node ${nodeId} (mesh ${mesh.id})`);
             }
         } catch (e: any) {

package/src/providers/approval-utils.ts

@@ -16,7 +16,7 @@ const DEFAULT_APPROVAL_POSITIVE_HINTS = [
     'always allow',
 ];
 
-function normalizeApprovalLabel(value: string): string {
+export function normalizeApprovalLabel(value: string): string {
     return String(value || '')
         .toLowerCase()
         .replace(/^[\s\[(<{]*\d+(?:\s*[.)\]}>:-]|\s)+/, '')

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

@@ -27,7 +27,7 @@ import { shouldCollectTraceCategory } from '../logging/debug-config.js';
 import { traceMeshEventStage, traceMeshEventDrop } from '../mesh/mesh-event-trace.js';
 import type { ChatMessage } from '../types.js';
 import { buildPersistedProviderEffectMessage, normalizeProviderEffects } from './control-effects.js';
-import { formatAutoApprovalMessage, pickApprovalButton, hasNegativeApprovalOption, hasReliableApprovalAffirmative, looksLikeActiveApprovalPromptText } from './approval-utils.js';
+import { formatAutoApprovalMessage, pickApprovalButton, hasNegativeApprovalOption, hasReliableApprovalAffirmative, looksLikeActiveApprovalPromptText, normalizeApprovalLabel } from './approval-utils.js';
 import { getCliScriptCommand, parseCliScriptResult } from './cli-script-results.js';
 import { mergeProviderPatchState, resolveProviderStateSurface } from './provider-patch-state.js';
 import { normalizeProviderSessionId } from './provider-session-id.js';
@@ -2317,19 +2317,31 @@ export class CliProviderInstance implements ProviderInstance {
             // kind gate). Surface the modal so the user decides; never pick blindly.
             return autoApproveActive;
         }
-        // Modal *identity* signature — the question/button set only, NO volatile
-        // counters. This is what the settle gate tracks: the FSM bumps
-        // approvalEntrySeq on every fresh waiting_approval entry, and a
-        // modal→generating→modal flap (the question line scrolled out of the
-        // captured frame while the button block stays) re-enters and bumps it
-        // again. Folding that seq into the settle signature made the 600ms
-        // settle clock restart on every flap, so the modal never stayed stable
-        // long enough to fire — the gate was never satisfied. Identity excludes
-        // the seq so button/seq flap of the SAME modal keeps one settle clock.
+        // Modal *identity* signature — the question plus the STABLE affirmative
+        // anchor only, NO volatile counters and NO raw button set. This is what
+        // the settle gate tracks: the FSM bumps approvalEntrySeq on every fresh
+        // waiting_approval entry, and a modal→generating→modal flap (the question
+        // line scrolled out of the captured frame while the button block stays)
+        // re-enters and bumps it again. Folding that seq into the settle signature
+        // made the 600ms settle clock restart on every flap, so the modal never
+        // stayed stable long enough to fire — the gate was never satisfied.
+        // Identity excludes the seq so seq flap of the SAME modal keeps one clock.
+        //
+        // The raw button set is also excluded: on a TALL Write/Edit diff claude's
+        // TUI repaints the button block 3↔5↔none between frames (buttons scroll in
+        // and out of the captured region), which flipped both buttons.join('|') and
+        // the positional buttonIndex every frame → signature flap → the settle
+        // clock reset 4–9s and only mask-stalled episodes leaked to the coordinator
+        // (AUTOAPPROVE-SETTLE-FLAP). The affirmative the auto-approve will actually
+        // press is the invariant across those repaints, so we anchor on its
+        // NORMALIZED label (numbers/bullets/punctuation stripped, so "1. Yes" and
+        // "3. Yes" collapse to "yes"). Message + affirmative label uniquely
+        // identifies the consent question without tracking the volatile button
+        // positions.
+        const affirmativeAnchor = normalizeApprovalLabel(buttonLabel);
         const modalSignature = [
             typeof modal?.message === 'string' ? modal.message.trim() : '',
-            buttons.join('|'),
-            buttonIndex,
+            affirmativeAnchor,
         ].join('::');
         // Busy-window re-entry guard still needs the seq: two DISTINCT
         // back-to-back approvals can carry identical message/buttons (common

package/src/repo-mesh-types.ts

@@ -1020,6 +1020,38 @@ export interface RepoMeshStatus {
      * Omitted when nothing was drained. Mirrors the MCP tool's meshProtocolMetrics.
      */
     meshProtocolMetrics?: MeshProtocolMetrics;
+    /**
+     * T6 (B3c): live process-lifetime mesh-protocol-v2 enforce counters from THIS
+     * daemon — the enforce flag state, drain-routing tallies (deliver / route-away /
+     * dedup / quarantine), and the last-resort backstop fire counts (PHASE-4 synth,
+     * acked-hold fast-track / death-deadline). Diagnostic-only and never cached (a
+     * live snapshot). Under enforce, non-zero quarantine or backstop counts are the
+     * rollout-health signal (target 0). Omitted when unavailable.
+     */
+    meshProtocolV2Counters?: MeshProtocolV2Counters;
+}
+
+/** T6 (B3c) live v2 enforce/observability counters (see RepoMeshStatus.meshProtocolV2Counters). */
+export interface MeshProtocolV2Counters {
+    /** True when MESH_PROTOCOL_V2_ENFORCE is active on this daemon. */
+    enforce: boolean;
+    /** Drain-path routing tallies (accept + enforce). Process-lifetime totals. */
+    drain: {
+        v2Delivered: number;
+        v2RoutedAway: number;
+        v2DedupSkipped: number;
+        v2ValidationFailedAccepted: number;
+        v2ReattributedToDrainer: number;
+        v1BroadcastAccepted: number;
+        v2ValidationFailedQuarantined: number;
+        v1UnversionedQuarantined: number;
+    };
+    /** Last-resort backstop fire counts. Target 0 under a healthy v2 contract. */
+    backstop: {
+        phase4SynthesisFired: number;
+        ackedHoldFastTrackFired: number;
+        ackedHoldDeathDeadlineFired: number;
+    };
 }
 
 /** One provider's version skew across mesh nodes (see RepoMeshStatus.providerVersionSkew). */