@@ -4,8 +4,11 @@ import { emitDiagnostic } from '@agent-device/host-kit/diagnostics';
 import type { ObservationClock } from './observe-until.ts';
 import {
   runPostGestureStabilityLoop,
+  type PostGestureBaseline,
   type PostGesturePreActionBaseline,
+  type PostGestureStabilityDecision,
   type PostGestureStabilityHooks,
+  type PostGestureStabilityPending,
 } from './post-gesture-stability.ts';
 
 vi.mock('@agent-device/host-kit/diagnostics', async (importOriginal) => {
@@ -19,6 +22,40 @@ beforeEach(() => {
 
 type Surface = Readonly<{ signature: readonly string[]; costMs: number; backend?: string }>;
 
+// The negative half of these lines is type-level: each @ts-expect-error fails `pnpm typecheck`
+// the moment the baseline union would accept a post-action reading as pre-action evidence again
+// (#3868). The pre-action-only slots are the pending record's baseline and the accept-stale
+// payload; only the writer may fill them.
+test('the baseline union rejects a post-action reading in every pre-action slot', () => {
+  const postAction: PostGestureBaseline<readonly string[]> = {
+    provenance: 'post-action',
+    signature: ['a'],
+    comparisonKey: 'key',
+  };
+  // @ts-expect-error a rebased baseline is not pre-action evidence for the pending record
+  const pendingBaseline: PostGesturePreActionBaseline<readonly string[]> = postAction;
+  const pending: PostGestureStabilityPending<readonly string[]> = {
+    action: 'scroll',
+    positionals: ['down'],
+    // @ts-expect-error a rebased baseline is not pre-action evidence for the pending record
+    baseline: postAction,
+  };
+  const decision = undefined as unknown as PostGestureStabilityDecision<readonly string[]>;
+  const consumeDistrust = () => {
+    if (decision.verdict === 'distrust') {
+      // @ts-expect-error a distrust decision exposes no pre-action baseline to consume
+      void decision.preActionBaseline;
+    }
+  };
+  // @ts-expect-error a baseline is constructed complete: the comparison key is not optional
+  const keyless: PostGesturePreActionBaseline<readonly string[]> = {
+    provenance: 'pre-action',
+    signature: ['a'],
+  };
+
+  void [pendingBaseline, pending, keyless, decision, consumeDistrust];
+});
+
 function fakeClock(): ObservationClock & { advance(ms: number): void } {
   let nowMs = 0;
   return {
 
@@ -45,7 +45,8 @@ export type BaselineSurfaceEvidence = 'changed' | 'unchanged' | 'ambiguous';
 /**
  * One surface reading that can stand as a comparison baseline. Signature and key travel together:
  * captures from different surfaces are not views of one screen (#1569, #2438). `comparisonKey` is
- * undefined for legacy observations that carry no key; absence is not proof of sameness.
+ * undefined for legacy observations that carry no key. A quiet pair with two absent keys does not
+ * rebase: absent keys never prove a surface change, and never prove sameness either.
  */
 export type PostGestureSurfaceReading<S> = Readonly<{
   signature: S;
@@ -149,7 +150,11 @@ export function decidePostGestureStabilityVerdict<S extends readonly unknown[]>(
   classifyBaselineEvidence: (baseline: S, quiet: S) => BaselineSurfaceEvidence;
 }): PostGestureStabilityDecision<S> {
   const { baseline, quietSignature, elapsedMs, distrustCapMs } = params;
-  if (baseline?.provenance !== 'pre-action') return { verdict: 'trust' };
+  // An empty baseline is no baseline: never classify against it, whatever the classifier does
+  // with empties. The writer normalizes `[]` away, so this guards a caller-constructed value.
+  if (baseline?.provenance !== 'pre-action' || baseline.signature.length === 0) {
+    return { verdict: 'trust' };
+  }
   if (params.classifyBaselineEvidence(baseline.signature, quietSignature) !== 'unchanged') {
     return { verdict: 'trust' };
   }
 
@@ -8,6 +8,7 @@ import {
 import {
   decidePostGestureStabilityVerdict as decideWithHooks,
   type PostGestureBaseline,
+  type PostGesturePreActionBaseline,
 } from '@agent-device/capture-kit/post-gesture-stability';
 import {
   applicationRootNode,
@@ -27,7 +28,7 @@ const decidePostGestureStabilityVerdict = (params: {
 
 function preActionBaseline(
   signature: InteractionSurfaceSignature,
-): PostGestureBaseline<InteractionSurfaceSignature> {
+): PostGesturePreActionBaseline<InteractionSurfaceSignature> {
   return { provenance: 'pre-action', signature, comparisonKey: 'runner|app' };
 }
 
@@ -58,6 +59,17 @@ test('decidePostGestureStabilityVerdict trusts immediately when no baseline was
     }),
     { verdict: 'trust' },
   );
+  // The writer never stores an empty signature, but a caller-constructed one is still no
+  // baseline: it must trust without ever consulting the classifier (#1542 base coverage).
+  assert.deepEqual(
+    decidePostGestureStabilityVerdict({
+      baseline: { provenance: 'pre-action', signature: [], comparisonKey: 'runner|app' },
+      quietSignature: signature,
+      elapsedMs: 0,
+      distrustCapMs: 3_500,
+    }),
+    { verdict: 'trust' },
+  );
 });
 
 test('decidePostGestureStabilityVerdict trusts a post-action baseline match at any elapsed time', () => {
 
@@ -132,8 +132,8 @@ function markSurfaceStabilization(
   // never stored: "no usable baseline" has exactly one
   // representation (absent), so no consumer has to tell `undefined` from `[]`
   // — and the loop cannot rebase a baseline that was never really there.
-  // Constructing the baseline here is also the whole distrust authorization: the
-  // loop is never separately told a platform boolean that could disagree.
+  // Constructing the baseline here is the whole distrust authorization. The loop is
+  // not given a second platform flag that could disagree with it.
   const baselineSignature = requiresPostGestureBaselineDistrust(session.device)
     ? buildInteractionSurfaceSignature(session.snapshot?.nodes ?? [])
     : undefined;