@@ -475,7 +475,7 @@ executable plan and must be in range. It is never a YAML line number, fractional
 repeat iteration label. Static includes, platform conditions, and fixed-count repeats expand before
 indexing, so repeated source lines are distinguished by their plan index.
 
-Every divergence includes `resume: { allowed, from, reason?, planDigest, repairSessionHeld? }`.
+Every divergence includes `resume: { allowed, from, reason?, planDigest, alternateFrom?, repairSessionHeld? }`.
 `from` is not merely the failed step's ordinal — it is the ordinal the caller should actually pass to
 `--from`, computed from the same `repairHint` carried alongside it (decision 6, R2/R3): for `record-and-heal`,
 `from` is the failed step's index **+ 1** (the agent performs that step manually before resuming, so
@@ -485,6 +485,22 @@ block and the `repairHint` text guidance below in agreement — a JSON/MCP-first
 at `resume.from` gets the same continuation a text caller reads out of the rendered guidance, never a stale
 `from` that loops the caller back onto the step it just repaired.
 
+`alternateFrom` is an **additive optional** ordinal (#1262) that makes the `caution`/`manual` dual-path
+structured-caller-legible, not text-only. Those two hints have TWO legitimate repairs the daemon cannot
+disambiguate at divergence time: an app-state fix (`--no-record`, then re-run the unchanged step at `from` =
+`N`), and a record-and-heal-shaped correction (perform the diverged step's intent as a recorded action, then
+resume PAST it at `N + 1`). `from` carries the first; `alternateFrom` carries the second (`N + 1`), present
+**only when a `--from N + 1` request for this divergence would actually be accepted** — the daemon computes
+it as `evaluateReplayResumePreflight({ from: N + 1, actions }).allowed`, which additionally requires the
+diverged step `N` itself to be skip-safe (so it is absent when `N` is a `runScript` outputEnv producer or
+sits inside runtime control flow, where `--from N + 1` would be refused). Because that preflight's checked
+range is a strict superset of `from`'s, `alternateFrom` present implies `allowed: true` — it never
+contradicts the primary. Absent for `record-and-heal` (its `from` already IS the `N + 1` continuation) and
+`state-repair` (no recorded-action alternate). The `repairHint` text guidance renders the `N + 1` command
+**iff `alternateFrom` is present**, never re-deriving resumability client-side, so the text surface and the
+structured wire advertise the identical next command — closing both the text-vs-structured disagreement a
+client-side re-derivation would reintroduce and the parity gap where a structured caller saw only `from`.
+
 If the shifted `from` equals `actions.length + 1` (the diverged step was the plan's LAST step), that is a
 legal EMPTY-TAIL resume, not an error: there is nothing left to replay, so the resumed run executes zero
 device actions and falls straight through to the normal end-of-plan completion path, correctly flipping an
 
@@ -219,12 +219,15 @@ test('a manual divergence (unannotated action-failure) on the LAST step resumes
   const divergence = leg1.error.details?.divergence as {
     kind: string;
     repairHint: string;
-    resume: { allowed: boolean; from: number; planDigest: string };
+    resume: { allowed: boolean; from: number; planDigest: string; alternateFrom?: number };
   };
   expect(divergence.kind).toBe('action-failure');
   expect(divergence.repairHint).toBe('manual');
   expect(divergence.resume.allowed).toBe(true);
   expect(divergence.resume.from).toBe(2);
+  // #1262: the wire carries the record-and-heal-shaped alternate (N + 1 = 3)
+  // — the diverged step is skip-safe, so `--from 3` would be accepted.
+  expect(divergence.resume.alternateFrom).toBe(3);
 
   const session = sessionStore.get(sessionName)!;
   expect(session.actions.map((a) => a.command)).toEqual(['open']);
@@ -348,12 +351,14 @@ test('a caution (identity-mismatch) divergence on the LAST step resumes with an
   const divergence = leg1.error.details?.divergence as {
     kind: string;
     repairHint: string;
-    resume: { allowed: boolean; from: number; planDigest: string };
+    resume: { allowed: boolean; from: number; planDigest: string; alternateFrom?: number };
   };
   expect(divergence.kind).toBe('identity-mismatch');
   expect(divergence.repairHint).toBe('caution');
   expect(divergence.resume.allowed).toBe(true);
   expect(divergence.resume.from).toBe(2);
+  // #1262: the wire carries the record-and-heal-shaped alternate (N + 1 = 3).
+  expect(divergence.resume.alternateFrom).toBe(3);
 
   const session = sessionStore.get(sessionName)!;
   expect(session.actions.map((a) => a.command)).toEqual(['open']);
 
@@ -138,11 +138,14 @@ test('buildReplayDivergenceResume reports allowed:true with from/planDigest for
     action({ command: 'open', positionals: ['Demo'] }),
     action({ command: 'click', positionals: ['label="Save"'] }),
   ];
+  // `state-repair` carries no `alternateFrom` (no recorded-action alternate),
+  // so this stays a clean base-shape assertion — the caution/manual
+  // `alternateFrom` cases are covered by the dedicated tests below.
   const resume = buildReplayDivergenceResume({
     failedIndex: 2,
     actions,
     planDigest: 'abc123',
-    repairHint: 'manual',
+    repairHint: 'state-repair',
   });
   assert.deepEqual(resume, { allowed: true, from: 2, planDigest: 'abc123' });
 });
@@ -229,6 +232,135 @@ test('buildReplayDivergenceResume with repairHint record-and-heal still rejects
   assert.match(resume.reason, /control flow/);
 });
 
+// --- buildReplayDivergenceResume: `resume.alternateFrom` (#1262). The
+// `caution`/`manual` dual-path's SECOND ordinal (`failedIndex + 1`), present
+// ONLY when a `--from failedIndex + 1` request would actually be accepted —
+// i.e. `evaluateReplayResumePreflight({ from: failedIndex + 1 })` passes,
+// which additionally requires the DIVERGED step itself to be skip-safe. This
+// closes the parity bug where the text renderer offered `--from N + 1` based
+// on `N`'s preflight (which does not check step `N`'s own skip-safety). ---
+
+test('buildReplayDivergenceResume: caution mid-plan (skip-safe diverged step) carries alternateFrom = failedIndex + 1', () => {
+  const actions: SessionAction[] = [
+    action({ command: 'open' }),
+    action({ command: 'click' }),
+    action({ command: 'click' }),
+  ];
+  const resume = buildReplayDivergenceResume({
+    failedIndex: 2,
+    actions,
+    planDigest: 'abc123',
+    repairHint: 'caution',
+  });
+  assert.equal(resume.allowed, true);
+  assert.equal(resume.from, 2); // unshifted
+  if (!resume.allowed) return;
+  assert.equal(resume.alternateFrom, 3);
+});
+
+test('buildReplayDivergenceResume: manual last-step (skip-safe diverged step) carries alternateFrom = actions.length + 1', () => {
+  const actions: SessionAction[] = [action({ command: 'open' }), action({ command: 'click' })];
+  const resume = buildReplayDivergenceResume({
+    failedIndex: 2,
+    actions,
+    planDigest: 'abc123',
+    repairHint: 'manual',
+  });
+  assert.equal(resume.allowed, true);
+  assert.equal(resume.from, 2);
+  if (!resume.allowed) return;
+  assert.equal(resume.alternateFrom, 3); // empty-tail ordinal
+});
+
+test('buildReplayDivergenceResume: caution whose diverged step is a runScript carries NO alternateFrom (mid-plan AND last-step)', () => {
+  // The `N + 1` alternate would skip the runScript (outputEnv producer) at
+  // step N, which `evaluateReplayResumePreflight({ from: N + 1 })` refuses —
+  // so alternateFrom is absent even though resuming AT N stays allowed.
+  const midPlan: SessionAction[] = [
+    action({ command: 'open' }),
+    action({ command: '__maestroRunScript', positionals: ['./setup.js'] }),
+    action({ command: 'click' }),
+  ];
+  const midPlanResume = buildReplayDivergenceResume({
+    failedIndex: 2,
+    actions: midPlan,
+    planDigest: 'abc123',
+    repairHint: 'caution',
+  });
+  assert.equal(midPlanResume.allowed, true); // resuming AT 2 is fine
+  assert.equal(midPlanResume.from, 2);
+  if (!midPlanResume.allowed) return;
+  assert.equal(midPlanResume.alternateFrom, undefined);
+
+  const lastStep: SessionAction[] = [
+    action({ command: 'open' }),
+    action({ command: '__maestroRunScript', positionals: ['./setup.js'] }),
+  ];
+  const lastStepResume = buildReplayDivergenceResume({
+    failedIndex: 2,
+    actions: lastStep,
+    planDigest: 'abc123',
+    repairHint: 'caution',
+  });
+  assert.equal(lastStepResume.allowed, true);
+  assert.equal(lastStepResume.from, 2);
+  if (!lastStepResume.allowed) return;
+  assert.equal(lastStepResume.alternateFrom, undefined);
+});
+
+test('buildReplayDivergenceResume: manual whose diverged step is inside runtime control flow carries NO alternateFrom (mid-plan AND last-step)', () => {
+  // A control-flow diverged step is not even resumable AT (you cannot resume
+  // INTO a retry/runFlowWhen wrapper), so `resume.allowed` is false and the
+  // `allowed: false` shape has no `alternateFrom` field at all — the key
+  // invariant is that no `N + 1` alternate is ever advertised for it.
+  const controlStep = () =>
+    action({
+      command: 'back',
+      positionals: [],
+      replayControl: { kind: 'retry', maxRetries: 1, actions: [action({ command: 'back' })] },
+    });
+  const midPlan: SessionAction[] = [
+    action({ command: 'open' }),
+    controlStep(),
+    action({ command: 'click' }),
+  ];
+  const midPlanResume = buildReplayDivergenceResume({
+    failedIndex: 2,
+    actions: midPlan,
+    planDigest: 'abc123',
+    repairHint: 'manual',
+  });
+  assert.equal('alternateFrom' in midPlanResume, false);
+
+  const lastStep: SessionAction[] = [action({ command: 'open' }), controlStep()];
+  const lastStepResume = buildReplayDivergenceResume({
+    failedIndex: 2,
+    actions: lastStep,
+    planDigest: 'abc123',
+    repairHint: 'manual',
+  });
+  assert.equal('alternateFrom' in lastStepResume, false);
+});
+
+test('buildReplayDivergenceResume: record-and-heal and state-repair never carry alternateFrom (no separate recorded-action alternate)', () => {
+  const actions: SessionAction[] = [
+    action({ command: 'open' }),
+    action({ command: 'click' }),
+    action({ command: 'click' }),
+  ];
+  for (const repairHint of ['record-and-heal', 'state-repair'] as const) {
+    const resume = buildReplayDivergenceResume({
+      failedIndex: 2,
+      actions,
+      planDigest: 'abc123',
+      repairHint,
+    });
+    assert.equal(resume.allowed, true);
+    if (!resume.allowed) return;
+    assert.equal(resume.alternateFrom, undefined, `expected no alternateFrom for ${repairHint}`);
+  }
+});
+
 // --- stampPendingRecordAndHealWatermark (#1262): the watermark is now ALSO
 // stamped for `caution`/`manual`, but ONLY for the LAST-step empty-tail
 // alternate (`failedIndex === actions.length`, targeting `failedIndex + 1`).
 
@@ -82,10 +82,23 @@ test('a failing replay step returns REPLAY_DIVERGENCE with cause preserved and c
 
   expect(divergence.suggestions).toEqual([]);
   expect(divergence.suggestionCount).toBe(0);
-  const resume = divergence.resume as { allowed: boolean; from: number; planDigest: string };
+  const resume = divergence.resume as {
+    allowed: boolean;
+    from: number;
+    planDigest: string;
+    alternateFrom?: number;
+  };
   // Step 1 ("open") is a plain action with no control flow and no outputEnv
-  // production, so resuming at the failed step (2) is safe.
-  expect(resume).toEqual({ allowed: true, from: 2, planDigest: expect.any(String) });
+  // production, so resuming at the failed step (2) is safe. This unannotated
+  // action-failure routes to `manual`, and the diverged step (2) is the plan's
+  // LAST and is itself skip-safe, so the #1262 record-and-heal-shaped alternate
+  // ordinal (`alternateFrom = 3`) rides the wire alongside the unshifted `from`.
+  expect(resume).toEqual({
+    allowed: true,
+    from: 2,
+    planDigest: expect.any(String),
+    alternateFrom: 3,
+  });
   expect(resume.planDigest).toMatch(/^[0-9a-f]{64}$/);
 });
 
 
@@ -84,6 +84,10 @@ function producesOutputEnv(action: SessionAction): boolean {
  * COMPLETE. Rejecting it here would send the agent to `close` instead —
  * which discards the just-recorded corrective action, since commit is gated
  * on that same COMPLETE flag.
+ *
+ * `alternateFrom` (#1262) is the `caution`/`manual` dual-path's SECOND
+ * ordinal (`failedIndex + 1`, the record-and-heal-shaped alternate) — see
+ * `computeReplayResumeAlternateFrom`.
  */
 export function buildReplayDivergenceResume(params: {
   failedIndex: number; // 1-based
@@ -94,9 +98,47 @@ export function buildReplayDivergenceResume(params: {
   const { failedIndex, actions, planDigest, repairHint } = params;
   const from = repairHint === 'record-and-heal' ? failedIndex + 1 : failedIndex;
   const preflight = evaluateReplayResumePreflight({ from, actions });
-  return preflight.allowed
-    ? { allowed: true, from, planDigest }
-    : { allowed: false, from, planDigest, reason: preflight.reason };
+  if (!preflight.allowed) return { allowed: false, from, planDigest, reason: preflight.reason };
+  const alternateFrom = computeReplayResumeAlternateFrom({ failedIndex, actions, repairHint });
+  return {
+    allowed: true,
+    from,
+    planDigest,
+    ...(alternateFrom !== undefined ? { alternateFrom } : {}),
+  };
+}
+
+/**
+ * ADR 0012 decision 4 / #1262: the `caution`/`manual` dual-path's SECOND
+ * ordinal, the record-and-heal-shaped alternate (`failedIndex + 1`). Returned
+ * ONLY when a `--from failedIndex + 1` request for this divergence would
+ * actually be accepted by the daemon — i.e. exactly its own resume preflight
+ * passes (`evaluateReplayResumePreflight`, which unlike `from`'s own preflight
+ * ALSO requires the DIVERGED step to be skip-safe, since reaching
+ * `failedIndex + 1` skips the diverged step). That preflight is the shared
+ * acceptance condition on BOTH the mid-plan path (un-gated, in range) and the
+ * last-step empty-tail path (`computeRecordAndHealWatermark` stamps on exactly
+ * this condition). Its checked range is a strict superset of `from`'s, so
+ * `alternateFrom` present implies `resume.allowed` — never a contradiction.
+ *
+ * Absent for `record-and-heal` (its `from` already IS `failedIndex + 1`) and
+ * `state-repair` (no recorded-action alternate); absent when the diverged step
+ * is a `runScript` (outputEnv producer) or inside runtime control flow, so the
+ * alternate `--from failedIndex + 1` would be refused. The text renderer gates
+ * the `N + 1` command on this field's PRESENCE rather than re-deriving
+ * resumability, keeping text and the structured wire in agreement.
+ */
+function computeReplayResumeAlternateFrom(params: {
+  failedIndex: number;
+  actions: SessionAction[];
+  repairHint: ReplayRepairHint;
+}): number | undefined {
+  const { failedIndex, actions, repairHint } = params;
+  if (repairHint !== 'caution' && repairHint !== 'manual') return undefined;
+  const alternateFrom = failedIndex + 1;
+  return evaluateReplayResumePreflight({ from: alternateFrom, actions }).allowed
+    ? alternateFrom
+    : undefined;
 }
 
 /**
 
@@ -1089,6 +1089,53 @@ test('MCP tool error is a ref-issuing result: isError, structuredContent, and pi
   assert.deepEqual(runCalls[1]?.input, { target: { kind: 'ref', ref: '@e5~s12' } });
 });
 
+// --- #1262: a `caution` divergence's dual-path must reach a structured caller,
+// not only text. `resume.alternateFrom` rides the MCP structuredContent
+// projection (parity with a text caller, who reads the second `--from`
+// command), and the MCP text carries BOTH concrete commands. ---
+test("MCP projections carry a caution divergence's alternateFrom (structuredContent) and both --from commands (text)", async () => {
+  const executor = createCommandToolExecutor({
+    createClient: () => ({}) as AgentDeviceClient,
+    runCommand: async (_client, name) => {
+      if (name === 'replay') {
+        throw new AppError('REPLAY_DIVERGENCE', 'Replay diverged at step 2 (click label="Save")', {
+          divergence: {
+            version: 1,
+            kind: 'identity-mismatch',
+            step: { index: 2, source: { path: '/tmp/flow.ad', line: 3 } },
+            action: 'click label="Save"',
+            cause: { code: 'IDENTITY_MISMATCH', message: 'resolved a different element' },
+            screen: {
+              state: 'available',
+              refsGeneration: 4,
+              refs: [{ ref: 'e1', role: 'button' }],
+            },
+            suggestions: [],
+            suggestionCount: 0,
+            resume: { allowed: true, from: 2, planDigest: 'deadbeef', alternateFrom: 3 },
+            repairHint: 'caution',
+          },
+        });
+      }
+      return {};
+    },
+  });
+
+  const result = await executor.execute('replay', { positionals: ['/tmp/flow.ad'] });
+  assert.equal(result.isError, true);
+  const structured = result.structuredContent as {
+    details?: { divergence?: { resume?: { from?: number; alternateFrom?: number } } };
+  };
+  // Parity: the structured caller gets BOTH ordinals, not just `from`.
+  assert.equal(structured.details?.divergence?.resume?.from, 2);
+  assert.equal(structured.details?.divergence?.resume?.alternateFrom, 3);
+  // The MCP text carries both concrete commands, the second from alternateFrom.
+  const text = result.content[0]?.text ?? '';
+  assert.match(text, /Repair hint: caution/);
+  assert.match(text, /if you fixed app state with --no-record actions: replay --from 2/);
+  assert.match(text, /if you performed the step's intent as a recorded action: replay --from 3/);
+});
+
 test('MCP tool error without a divergence never touches existing pins (merge-only)', async () => {
   const runCalls: Array<{ name: string; input: unknown }> = [];
   const executor = createCommandToolExecutor({