You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maka.apache.org by wy...@apache.org on 2026/09/07 05:10:25 UTC

(maka) 01/01: feat(runtime-host): add cooperative handoff and live recovery surfaces

This is an automated email from the ASF dual-hosted git repository.

M4n5ter pushed a commit to branch feat/runtime-host-handoff
in repository https://gitbox.apache.org/repos/asf/maka.git

commit 1e1127bd73564a298e08535ce5fe85550b94f294
Author: M4n5ter <m4...@gmail.com>
AuthorDate: Mon Sep 7 13:08:15 2026 +0800

    feat(runtime-host): add cooperative handoff and live recovery surfaces
    
    Keep logical turn ownership across authenticated safepoint continuation, fence local replacement authority, and share a cancellable handoff journey across Desktop and CLI.
    
    Generated-by: Codex
---
 .../main/__tests__/main-startup-lifetime.test.ts   |  10 +-
 .../__tests__/native-diagnostic-dialog.test.ts     |  52 ---
 .../runtime-host-desktop-candidate.test.ts         | 141 ++++--
 .../__tests__/runtime-host-desktop-manager.test.ts | 451 ++++++------------
 .../__tests__/runtime-host-local-operator.test.ts  |  41 ++
 .../runtime-host-startup-recovery.test.ts          | 124 -----
 .../__tests__/runtime-host-upgrade-dialog.test.ts  | 165 -------
 .../main/__tests__/startup-progress-window.test.ts |  27 +-
 .../src/main/native-diagnostic-dialog-copy.ts      |  44 --
 apps/desktop/src/main/native-diagnostic-dialog.ts  |  32 --
 apps/desktop/src/main/runtime-host-boot.ts         |  67 +--
 apps/desktop/src/main/runtime-host-client.ts       |   2 +-
 .../src/main/runtime-host-desktop-manager.ts       | 282 ++++++------
 .../src/main/runtime-host-local-operator.ts        |  23 +-
 .../src/main/runtime-host-local-remote-access.ts   | 109 ++++-
 .../src/main/runtime-host-startup-recovery.ts      | 104 -----
 apps/desktop/src/main/runtime-host-upgrade-copy.ts | 212 ---------
 .../src/main/runtime-host-upgrade-dialog.ts        |  61 ---
 apps/desktop/src/main/startup-presentation.ts      |  55 ++-
 apps/desktop/src/main/startup-progress-window.ts   |  86 +++-
 .../src/__tests__/runtime-host-cli-context.test.ts |  74 +--
 .../runtime-host-lifecycle-transaction.test.ts     |  64 +++
 .../__tests__/runtime-host-local-handoff.test.ts   |  28 ++
 .../runtime-host-operator-retirement.test.ts       |  47 ++
 packages/cli/src/cli-core.ts                       |   1 +
 packages/cli/src/runtime-host-cli-context.ts       | 233 ++++++----
 packages/cli/src/runtime-host-cli.ts               |   6 +-
 packages/cli/src/runtime-host-handoff-surface.ts   |  94 ++++
 .../cli/src/runtime-host-lifecycle-transaction.ts  |  16 +
 packages/cli/src/runtime-host-local-handoff.ts     |  29 ++
 .../src/runtime-host-local-source-retirement.ts    |  19 +-
 .../src/runtime-host-managed-lifecycle-manager.ts  |   1 +
 .../cli/src/runtime-host-operator-retirement.ts    |  57 +++
 packages/cli/src/runtime-host-service-manager.ts   |   7 +
 packages/cli/src/runtime-host-tui-command.ts       |  88 +---
 packages/cli/src/runtime-host-tui-context.ts       |   3 +
 packages/core/package.json                         |   2 +
 .../core/src/__tests__/runtime-boundary.test.ts    |  56 ++-
 .../core/src/__tests__/runtime-handoff.test.ts     |  97 ++++
 packages/core/src/backend-types.ts                 |  10 +-
 packages/core/src/canonical-runtime-event.ts       |   4 +-
 packages/core/src/runtime-boundary.ts              |  61 ++-
 packages/core/src/runtime-event.ts                 |  46 +-
 packages/core/src/runtime-handoff.ts               | 137 ++++++
 packages/core/src/runtime-invocation.ts            |   2 +-
 packages/core/src/runtime-logical-execution.ts     | 159 +++++++
 .../__tests__/canonical-session-projection.test.ts |   1 +
 .../src/__tests__/connection-session.test.ts       | 151 +++---
 .../src/__tests__/execution-composition.test.ts    | 140 +++++-
 .../src/__tests__/goal-root-authority.test.ts      |   1 +
 .../src/__tests__/host-handoff.test.ts             | 504 +++++++++++++++++++++
 .../runtime-host/src/__tests__/host-kernel.test.ts | 169 ++++++-
 .../src/__tests__/host-retirement.test.ts          |  45 ++
 .../src/__tests__/message-coordinator.test.ts      |   1 +
 .../src/__tests__/root-turn-coordinator.test.ts    | 412 ++++++++++++++++-
 .../scheduled-task-coordinator-recovery.test.ts    |  90 ++++
 .../__tests__/session-transcript-reader.test.ts    |   4 +-
 packages/runtime-host/src/client/connection.ts     |   5 +
 .../runtime-host/src/client/host-handoff-copy.ts   | 177 ++++++++
 packages/runtime-host/src/client/host-handoff.ts   | 365 +++++++++++++++
 .../runtime-host/src/client/host-retirement.ts     |  38 +-
 packages/runtime-host/src/client/index.ts          |   2 +
 .../src/client/remote-compatibility-error.ts       |   2 +
 packages/runtime-host/src/operator/index.ts        |   1 +
 .../src/operator/retirement-cancellation.ts        |  22 +
 packages/runtime-host/src/protocol/host-status.ts  |  52 ++-
 packages/runtime-host/src/protocol/index.ts        |  12 +-
 .../src/server/canonical-turn-snapshot.ts          |   9 +-
 .../runtime-host/src/server/connection-session.ts  |  18 +-
 .../src/server/execution-composition.ts            |  60 ++-
 .../runtime-host/src/server/goal-coordinator.ts    |  45 ++
 packages/runtime-host/src/server/host-kernel.ts    | 132 +++++-
 .../src/server/host-residency-registry.ts          |  23 +-
 .../server/hosted-execution-admission-registry.ts  |   4 +-
 .../src/server/hosted-execution-recovery.ts        |   9 +-
 .../runtime-host/src/server/message-coordinator.ts | 119 ++++-
 .../src/server/operation-dispatcher.ts             |   2 +
 .../src/server/root-turn-coordinator.ts            | 430 +++++++++++++++---
 .../src/server/scheduled-task-coordinator.ts       |  39 +-
 .../src/server/session-transcript-reader.ts        |  68 ++-
 .../runtime/src/__tests__/ai-sdk-backend.test.ts   | 120 +++++
 .../src/__tests__/goal-continuation.test.ts        |  33 ++
 .../runtime/src/__tests__/run-handoff-gate.test.ts |  71 +++
 .../src/__tests__/runtime-event-read-model.test.ts |  12 +
 .../runtime/src/__tests__/runtime-handoff.test.ts  | 252 +++++++++++
 .../runtime/src/__tests__/session-manager.test.ts  |  13 +-
 packages/runtime/src/agent-run.ts                  | 171 ++++++-
 packages/runtime/src/ai-sdk-turn.ts                |  27 +-
 packages/runtime/src/continuation-replay.ts        |   4 +-
 packages/runtime/src/conversation-copy.ts          |  16 +-
 packages/runtime/src/goal-continuation.ts          |  39 +-
 packages/runtime/src/run-handoff-gate.ts           | 114 +++++
 packages/runtime/src/runtime-event-read-model.ts   |   7 +-
 packages/runtime/src/runtime-kernel.ts             | 113 ++++-
 packages/runtime/src/runtime-resume.ts             | 127 +++++-
 packages/runtime/src/session-manager.ts            | 132 ++++--
 .../__tests__/invocation-opening-backfill.test.ts  |   8 +-
 .../src/__tests__/sqlite-runtime-schema.test.ts    |   5 +-
 .../src/__tests__/sqlite-runtime-store.test.ts     | 173 +++++++
 packages/storage/src/sqlite-runtime-schema.ts      |  38 +-
 packages/storage/src/sqlite-runtime-store.ts       |  62 ++-
 scripts/check-tui-copy.mjs                         |   9 +-
 102 files changed, 6172 insertions(+), 1955 deletions(-)

diff --git a/apps/desktop/src/main/__tests__/main-startup-lifetime.test.ts b/apps/desktop/src/main/__tests__/main-startup-lifetime.test.ts
index d43b28a061..713e67f40a 100644
--- a/apps/desktop/src/main/__tests__/main-startup-lifetime.test.ts
+++ b/apps/desktop/src/main/__tests__/main-startup-lifetime.test.ts
@@ -79,27 +79,21 @@ test('resolves persisted locale before first post-settings recovery prompt', ()
     rendererRecoveryStart,
     bootSource.indexOf('resolveBrowserDialogParent =', rendererRecoveryStart),
   );
-  const hostRecoveryStart = bootSource.indexOf('prompt: async (input)');
-  const hostRecovery = bootSource.slice(
-    hostRecoveryStart,
-    bootSource.indexOf('}).catch((error: unknown)', hostRecoveryStart),
-  );
   const defaultHostRecoveryStart = bootSource.indexOf(
     'async function promptForDefaultRuntimeHostRecovery',
   );
   const defaultHostRecovery = bootSource.slice(defaultHostRecoveryStart);
 
   assert.match(rendererRecovery, /const locale = await desktopLocale\.resolve\(\)/u);
-  assert.match(hostRecovery, /const locale = await desktopLocale\.resolve\(\)/u);
+  assert.match(bootSource, /handoffSurface: createDesktopHostHandoffSurface\(\(\) => desktopLocale\.resolve\(\)\)/u);
   assert.match(defaultHostRecovery, /const locale = await desktopLocale\.resolve\(\)/u);
   assert.doesNotMatch(rendererRecovery, /desktopLocale\.current\(\)/u);
-  assert.doesNotMatch(hostRecovery, /desktopLocale\.current\(\)/u);
   assert.doesNotMatch(defaultHostRecovery, /resolveSystemUiLocale/u);
 });
 
 test('lets the Runtime Host migrate its State Root before Desktop opens shared tables', () => {
   const hostStart = bootSource.indexOf(
-    'runtimeHostManager = await startDesktopRuntimeHostWithRecovery',
+    'runtimeHostManager = await startLocalRuntimeHostManager',
   );
   const workBoardOpen = bootSource.indexOf(
     'store: createWorkBoardStore(workspaceRoot',
diff --git a/apps/desktop/src/main/__tests__/native-diagnostic-dialog.test.ts b/apps/desktop/src/main/__tests__/native-diagnostic-dialog.test.ts
index 954f0d89b6..c105e0f27d 100644
--- a/apps/desktop/src/main/__tests__/native-diagnostic-dialog.test.ts
+++ b/apps/desktop/src/main/__tests__/native-diagnostic-dialog.test.ts
@@ -30,7 +30,6 @@ import {
   showFatalStartupError,
   showMainRendererProcessGoneDialog,
   showMessageBoxWithDiagnostics,
-  showRuntimeHostStartupRecoveryDialog,
 } from '../native-diagnostic-dialog.js';
 
 const diagnosticEnvironment = () => ({
@@ -193,54 +192,3 @@ test('main Renderer loss keeps Copy Diagnostics auxiliary to recovery', async ()
   assert.match(clipboard, /Recent main-process logs \(1\)/);
   assert.doesNotMatch(clipboard, /very-secret-token/);
 });
-
-test('managed Host recovery preserves the workspace and confirms active-work interruption', async () => {
-  let shown: MessageBoxOptions | undefined;
-  const decision = await showRuntimeHostStartupRecoveryDialog(
-    {
-      startupError: new Error('managed service unavailable'),
-      repairError: new Error('service update failed'),
-      activeTasks: true,
-    },
-    {
-      locale: 'en',
-      copyDiagnostics() {},
-      showMessageBox: async (options): Promise<MessageBoxReturnValue> => {
-        shown = options;
-        return { response: 0, checkboxChecked: false };
-      },
-    },
-  );
-
-  assert.equal(decision, 'repair');
-  assert.deepEqual(shown?.buttons, [
-    'Repair and Restart Host',
-    'Exit',
-    'Copy Diagnostics',
-  ]);
-  assert.equal(shown?.defaultId, shown?.cancelId);
-  assert.match(shown?.detail ?? '', /workspace, Host identity, credentials, and settings/);
-  assert.match(shown?.detail ?? '', /automatic update compatibility cannot be confirmed/);
-  assert.match(shown?.detail ?? '', /interrupt that work/);
-  assert.match(shown?.detail ?? '', /Copy diagnostics to inspect the details/);
-  assert.doesNotMatch(shown?.detail ?? '', /service update failed/);
-
-  let unknownShown: MessageBoxOptions | undefined;
-  const unknownDecision = await showRuntimeHostStartupRecoveryDialog(
-    {
-      startupError: new Error('managed service unavailable'),
-      repairError: new Error('safe repair could not verify Host activity'),
-      activeTasks: false,
-    },
-    {
-      locale: 'en',
-      copyDiagnostics() {},
-      showMessageBox: async (options): Promise<MessageBoxReturnValue> => {
-        unknownShown = options;
-        return { response: 1, checkboxChecked: false };
-      },
-    },
-  );
-  assert.equal(unknownDecision, 'exit');
-  assert.equal(unknownShown?.defaultId, unknownShown?.cancelId);
-});
diff --git a/apps/desktop/src/main/__tests__/runtime-host-desktop-candidate.test.ts b/apps/desktop/src/main/__tests__/runtime-host-desktop-candidate.test.ts
index 03c14672be..fe13b9953a 100644
--- a/apps/desktop/src/main/__tests__/runtime-host-desktop-candidate.test.ts
+++ b/apps/desktop/src/main/__tests__/runtime-host-desktop-candidate.test.ts
@@ -35,7 +35,7 @@ import type {
   ConnectOrSpawnRuntimeHostInput,
   RuntimeHostConnection,
 } from '@maka/runtime-host/client';
-import { RuntimeHostOperationError } from '@maka/runtime-host/client';
+import { RuntimeHostOperationError, runHostHandoff } from '@maka/runtime-host/client';
 import {
   SESSION_CONTINUITY_SCHEMA_VERSION,
   type ClientCapabilityCallFrame,
@@ -60,7 +60,7 @@ import { RuntimeHostSessionObservationRegistry } from '../runtime-host-session-o
 import { RuntimeHostReconnectingIpcMain } from '../runtime-host-reconnecting-ipc-main.js';
 import { desktopSessionResourceKey } from '../../shared/runtime-host-identity.js';
 import { waitFor as pollFor } from '@maka/core/test-only/async-primitives';
-import { startDesktopRuntimeHostWithRecovery } from '../runtime-host-startup-recovery.js';
+import { canRepairManagedRuntimeHostStartup } from '../runtime-host-startup-recovery.js';
 
 const TEST_HOST_ID = 'a'.repeat(64);
 const TEST_TARGET_EPOCH = 'test-target-epoch';
@@ -113,52 +113,115 @@ test('updates a protocol-compatible managed Host before exposing a candidate ove
   const updated = connectionHarness('updated');
   let starts = 0;
   let repairs = 0;
-  const candidate = await startDesktopRuntimeHostWithRecovery({
-    start: async () => {
-      const host = starts++ === 0 ? old : updated;
-      const result = await startDesktopRuntimeHostCandidate({
-        ...deps(ipc),
-        workspaceRoot: root,
-        rootPath: root,
-        candidateEntrypoint: 'unused.js',
-        candidateLaunchBarrier: {
-          connect: async () => ({
-            kind: 'connected',
-            connection: host.connection,
-            registration: { lifecycleMode: 'supervised', pid: 123 },
-          }),
-        },
-      } as unknown as DesktopRuntimeHostCandidateStartInput);
-      assert.equal(result.kind, 'ready');
-      if (result.kind !== 'ready') throw new Error('Expected a ready candidate');
-      return result.candidate;
-    },
-    repair: async (authority) => {
-      repairs += 1;
-      assert.deepEqual(authority, { allowManualUpdate: false, allowInterruptActiveTasks: false });
-      assert.equal(old.closeCalls, 1, 'release the old connection before managed update');
-      assert.equal(old.capabilityRegistrations, 0, 'do not expose capabilities before storage admission');
-      assert.equal(ipc.size, 0);
-      const preserved = new DatabaseSync(databasePath, { readOnly: true });
+  const candidate = await runHostHandoff({
+    observe: async () => {
       try {
-        assert.equal(preserved.prepare("SELECT version FROM operational_schema_migrations WHERE scope = 'usage'").get()?.version, 6);
-        assert.equal(preserved.prepare("SELECT record_json FROM usage_model_call_attempts WHERE attempt_id = 'retained'").get()?.record_json, '{}');
-      } finally {
-        preserved.close();
+        const host = starts++ === 0 ? old : updated;
+        const result = await startDesktopRuntimeHostCandidate({
+          ...deps(ipc),
+          workspaceRoot: root,
+          rootPath: root,
+          candidateEntrypoint: 'unused.js',
+          candidateLaunchBarrier: {
+            connect: async () => ({
+              kind: 'connected',
+              connection: host.connection,
+              registration: { lifecycleMode: 'supervised', pid: 123 },
+            }),
+          },
+        } as unknown as DesktopRuntimeHostCandidateStartInput);
+        assert.equal(result.kind, 'ready');
+        if (result.kind !== 'ready')
+          throw new Error('Expected a ready candidate');
+        return { kind: 'ready', value: result.candidate };
+      } catch (error) {
+        assert.ok(
+          error instanceof Error && canRepairManagedRuntimeHostStartup(error),
+        );
+        return {
+          kind: 'blocked',
+          blocker: {
+            identity: 'managed-schema-before',
+            target: { name: 'Local', location: 'local' },
+            reason: 'repair',
+            mayExitNaturally: false,
+            activity: {
+              connections: 0,
+              activeOperations: 0,
+              processUptimeSeconds: 1,
+              residencies: [],
+            },
+            replacement: {
+              kind: 'repair',
+              canReplaceIdle: true,
+              canInterrupt: true,
+              execute: async (authority) => {
+                repairs += 1;
+                assert.equal(authority, 'refuse_active_work');
+                assert.equal(
+                  old.closeCalls,
+                  1,
+                  'release the old connection before managed update',
+                );
+                assert.equal(
+                  old.capabilityRegistrations,
+                  0,
+                  'do not expose capabilities before storage admission',
+                );
+                assert.equal(ipc.size, 0);
+                const preserved = new DatabaseSync(databasePath, {
+                  readOnly: true,
+                });
+                try {
+                  assert.equal(
+                    preserved
+                      .prepare(
+                        "SELECT version FROM operational_schema_migrations WHERE scope = 'usage'",
+                      )
+                      .get()?.version,
+                    6,
+                  );
+                  assert.equal(
+                    preserved
+                      .prepare(
+                        "SELECT record_json FROM usage_model_call_attempts WHERE attempt_id = 'retained'",
+                      )
+                      .get()?.record_json,
+                    '{}',
+                  );
+                } finally {
+                  preserved.close();
+                }
+                // Simulate the updated owning Host, not Desktop, performing migration.
+                acquireOperationalStateDatabase(root).close();
+                return { kind: 'completed' };
+              },
+            },
+          },
+        };
       }
-      // Simulate the updated owning Host, not Desktop, performing migration.
-      acquireOperationalStateDatabase(root).close();
-      return { kind: 'repaired' };
     },
-    prompt: async () => { throw new Error('No prompt needed for an idle automatically updatable Host'); },
+    openSurface: () => ({
+      update: (view) => assert.equal(view.state, 'progress', 'idle repair needs no consent'),
+      close: () => {},
+    }),
   });
   t.after(() => candidate.close());
   assert.equal(starts, 2);
   assert.equal(repairs, 1);
   assert.equal(updated.capabilityRegistrations, 1);
-  const current = acquireOperationalStateDatabase(root, { schemaMigration: 'require_current' });
+  const current = acquireOperationalStateDatabase(root, {
+    schemaMigration: 'require_current',
+  });
   try {
-    assert.equal(current.database.prepare("SELECT session_id FROM usage_model_call_attempts WHERE attempt_id = 'retained'").get()?.session_id, 'deleted-session');
+    assert.equal(
+      current.database
+        .prepare(
+          "SELECT session_id FROM usage_model_call_attempts WHERE attempt_id = 'retained'",
+        )
+        .get()?.session_id,
+      'deleted-session',
+    );
   } finally {
     current.close();
   }
diff --git a/apps/desktop/src/main/__tests__/runtime-host-desktop-manager.test.ts b/apps/desktop/src/main/__tests__/runtime-host-desktop-manager.test.ts
index 0bcb2c7de6..9fb28dac17 100644
--- a/apps/desktop/src/main/__tests__/runtime-host-desktop-manager.test.ts
+++ b/apps/desktop/src/main/__tests__/runtime-host-desktop-manager.test.ts
@@ -26,6 +26,10 @@ import {
   RuntimeHostPermanentReconnectError,
   RuntimeHostRequestInterruptedError,
   type RuntimeHostSpawnedProcess,
+  type HostHandoffView,
+  type HostHandoffAction,
+  type OpenHostHandoffSurface,
+  HostHandoffRequiredError,
 } from '@maka/runtime-host/client';
 import {
   INTERACTIVE_RUNTIME_HOST_COMPOSITION_ID,
@@ -680,14 +684,12 @@ test('does not poll a remote service PID when the Host cannot be replaced', asyn
     {
       startCandidate: async (input) =>
         input.profileTarget ? conflict : ready(local.candidate),
-      upgradePrompts: {
-        restartable: async () => assert.fail('non-restartable conflict used restart prompt'),
-        nonRestartable: async (_conflict, action) => {
-          assert.equal(action, 'cancel_only');
-          return 'cancel';
-        },
-      },
-      waitForHostRetirement: async () => assert.fail('remote PID must not be polled locally'),
+      handoffSurface: decideHandoff((view) => {
+        assert.deepEqual(view.actions, ['cancel', 'retry']);
+        assert.equal(view.target.location, 'remote');
+        assert.equal(view.mayExitNaturally, false);
+        return 'cancel';
+      }),
     },
   );
 
@@ -1243,9 +1245,11 @@ test('keeps an initially unavailable Direct target live and wakes it on new rout
   await manager.close();
 });
 
-test('does not activate a Direct target whose immediate retry fails permanently', async () => {
+test('marks a retrying Direct target unavailable on permanent failure', async () => {
   const local = candidateHarness();
   const permanent = new RuntimeHostPermanentReconnectError('credential rejected');
+  let reportFatal!: (error: Error) => void;
+  const failed = new Promise<Error>((resolve) => { reportFatal = resolve; });
   let starts = 0;
   const manager = await startRuntimeHostDesktopManager(
     {} as DesktopRuntimeHostCandidateStartInput,
@@ -1256,10 +1260,12 @@ test('does not activate a Direct target whose immediate retry fails permanently'
         if (starts === 2) throw new Error('route is temporarily unavailable');
         throw permanent;
       },
+      onFatalError: reportFatal,
     },
   );
 
-  await assert.rejects(manager.enable(peerTarget('office')), (error: unknown) => error === permanent);
+  await manager.enable(peerTarget('office')).catch((error) => assert.equal(error, permanent));
+  assert.equal(await failed, permanent);
   assert.equal(starts, 3);
   assert.equal(manager.current('office'), undefined);
   const state = manager.entries().find((entry) => entry.target.profile.id === 'office');
@@ -1369,7 +1375,7 @@ test('stops reconnecting when the replacement Host is incompatible', async () =>
 
   await first.candidate.close();
   const fatal = await fatalReported;
-  assert.match(fatal.message, /older Runtime Host/);
+  assert.ok(fatal instanceof HostHandoffRequiredError);
   await assert.rejects(
     owner.retireOwnedLocalHost('interrupt_active_work'),
     (error: unknown) =>
@@ -1429,341 +1435,176 @@ test('does not block quit after a supervised Local Host becomes permanently unav
   await owner.close();
 });
 
-test('restarts an idle generation-aware Host without prompting', async () => {
+test('automatically replaces a proven-idle managed Host without an interruption decision', async () => {
+  const observed = upgradeRequired(true);
+  const conflict = { ...observed, restartable: false as const,
+    registration: { ...observed.registration, lifecycleMode: 'service' as const } };
   const replacement = candidateHarness();
-  const starts: DesktopRuntimeHostCandidateStartInput[] = [];
-  const conflict = upgradeRequired(true);
+  let replaced = false;
   const owner = await startRuntimeHostDesktopManager({} as DesktopRuntimeHostCandidateStartInput, {
-    startCandidate: async (input) => {
-      starts.push(input);
-      return starts.length === 1 ? conflict : ready(replacement.candidate);
-    },
-    upgradePrompts: {
-      restartable: async () => assert.fail('idle Host must not prompt before restart'),
-      nonRestartable: async () => assert.fail('restartable conflict used non-restartable prompt'),
-    },
+    startCandidate: async () => replaced ? ready(replacement.candidate) : conflict,
+    handoffSurface: () => ({
+      update: (view) => { assert.equal(view.state, 'progress'); assert.ok(!view.actions.includes('interrupt')); },
+      close: () => undefined,
+    }),
+    resolveLocalHostReplacement: async (registration) => ({
+      identity: 'managed-owner', canReplaceIdle: true,
+      replace: async (policy) => {
+        assert.equal(registration.hostEpoch, conflict.registration.hostEpoch);
+        assert.equal(policy, 'refuse_active_work');
+        replaced = true;
+        return 'replaced';
+      },
+    }),
   });
-
-  assert.equal(starts.length, 2);
-  assert.equal(starts[1]?.takeoverHostEpoch, conflict.registration.hostEpoch);
   await owner.close();
 });
 
-test('prompts before restarting a generation-aware Host with observed activity', async () => {
-  const conflicts = [
-    ['operation', upgradeRequired(true, 1)],
-    ['residency', upgradeRequired(true, 0, [{ label: 'goal', count: 1 }])],
-    ['connection', upgradeRequired(true, 0, [], 1)],
-  ] as const;
-
-  for (const [activity, conflict] of conflicts) {
+test('active and unknown work use the shared explicit interruption decision', async () => {
+  for (const observed of [
+    upgradeRequired(true, 1), upgradeRequired(true, 0, [{ label: 'goal', count: 1 }]),
+    upgradeRequired(true, 0, [], 1), upgradeRequired(false),
+  ]) {
+    const conflict = { ...observed, restartable: false as const,
+      registration: { ...observed.registration, lifecycleMode: 'service' as const } };
     const replacement = candidateHarness();
-    let prompts = 0;
-    const owner = await startRuntimeHostDesktopManager(
-      {} as DesktopRuntimeHostCandidateStartInput,
-      {
-        startCandidate: async (input) =>
-          input.takeoverHostEpoch ? ready(replacement.candidate) : conflict,
-        upgradePrompts: {
-          restartable: async () => {
-            prompts += 1;
-            return 'restart';
-          },
-          nonRestartable: async () =>
-            assert.fail('restartable conflict used non-restartable prompt'),
+    let replaced = false;
+    const owner = await startRuntimeHostDesktopManager({} as DesktopRuntimeHostCandidateStartInput, {
+      startCandidate: async () => replaced ? ready(replacement.candidate) : conflict,
+      handoffSurface: decideHandoff((view) => {
+        assert.equal(view.defaultAction, 'cancel');
+        assert.ok(view.actions.includes('interrupt'));
+        return 'interrupt';
+      }),
+      resolveLocalHostReplacement: async () => ({
+        canReplaceIdle: true,
+        replace: async (policy) => {
+          assert.equal(policy, 'interrupt_active_work');
+          replaced = true;
+          return 'replaced';
         },
-      },
-    );
-
-    assert.equal(prompts, 1, activity);
+      }),
+    });
     await owner.close();
   }
 });
 
-test('prompts when a restartable Host has no activity snapshot', async () => {
+test('an admission race needs fresh explicit consent instead of repeated automatic replacement', async () => {
+  const observed = upgradeRequired(true);
+  const conflict = { ...observed, restartable: false as const,
+    registration: { ...observed.registration, lifecycleMode: 'service' as const } };
   const replacement = candidateHarness();
-  const conflict = upgradeRequired(true, 0, [], 0, false);
-  let prompts = 0;
+  let replaced = false;
+  const policies: string[] = [];
   const owner = await startRuntimeHostDesktopManager({} as DesktopRuntimeHostCandidateStartInput, {
-    startCandidate: async (input) =>
-      input.takeoverHostEpoch ? ready(replacement.candidate) : conflict,
-    upgradePrompts: {
-      restartable: async () => {
-        prompts += 1;
-        return 'restart';
-      },
-      nonRestartable: async () => assert.fail('restartable conflict used non-restartable prompt'),
-    },
-  });
-
-  assert.equal(prompts, 1);
-  await owner.close();
-});
-
-test('waits passively for a Host that cannot be taken over', async () => {
-  const observed = upgradeRequired(false);
-  const conflict = {
-    ...observed,
-    registration: { ...observed.registration, lifecycleMode: 'service' as const },
-  };
-  let starts = 0;
-  let finishRetirement!: () => void;
-  const retirement = new Promise<void>((resolve) => {
-    finishRetirement = resolve;
-  });
-  const replacement = candidateHarness();
-  const ownerTask = startRuntimeHostDesktopManager({} as DesktopRuntimeHostCandidateStartInput, {
-    startCandidate: async () => {
-      starts += 1;
-      return starts === 1 ? conflict : ready(replacement.candidate);
-    },
-    upgradePrompts: {
-      restartable: async () => assert.fail('wait-only conflict used restart prompt'),
-      nonRestartable: async (_conflict, action) => {
-        assert.equal(action, 'wait');
-        return 'wait';
+    startCandidate: async () => replaced ? ready(replacement.candidate) : conflict,
+    handoffSurface: decideHandoff(() => 'interrupt'),
+    resolveLocalHostReplacement: async () => ({
+      canReplaceIdle: true,
+      replace: async (policy) => {
+        policies.push(policy);
+        if (policy === 'refuse_active_work') return 'active_tasks';
+        replaced = true;
+        return 'replaced';
       },
-    },
-    waitForHostRetirement: async (registration) => {
-      assert.equal(registration.hostEpoch, conflict.registration.hostEpoch);
-      await retirement;
-    },
+    }),
   });
-  await new Promise<void>((resolve) => setImmediate(resolve));
-  assert.equal(starts, 1);
-  finishRetirement();
-  const owner = await ownerTask;
-  assert.equal(starts, 2);
+  assert.deepEqual(policies, ['refuse_active_work', 'interrupt_active_work']);
   await owner.close();
 });
 
-test('offers to stop an exact local ephemeral Host before retrying startup', async () => {
+test('an exact legacy ephemeral stop always requires consent and preserves the OS lifetime fence', async () => {
   const observed = incompatibleHost('blocked_by_residency');
-  const conflict = {
-    ...observed,
+  const conflict = { ...observed,
     registration: { ...observed.registration, lifecycleMode: 'ephemeral' as const },
-    processIdentity: {
-      startIdentity: 'darwin:1700000000:123456',
-    },
-    handshake: {
-      ...observed.handshake,
-      activity: {
-        connections: 0,
-        activeOperations: 0,
-        processUptimeSeconds: 60,
-        residencies: [],
-      },
-    },
+    processIdentity: { startIdentity: 'darwin:1700000000:123456' },
+    handshake: { ...observed.handshake, activity: {
+      connections: 0, activeOperations: 0, processUptimeSeconds: 60, residencies: [],
+    } },
   };
   const replacement = candidateHarness();
-  let starts = 0;
-  let prompts = 0;
-  let terminations = 0;
+  let terminated = false;
   const owner = await startRuntimeHostDesktopManager(
-    { rootPath: '/workspace' } as DesktopRuntimeHostCandidateStartInput,
-    {
-      startCandidate: async () => {
-        starts += 1;
-        return starts === 1 ? conflict : ready(replacement.candidate);
-      },
-      upgradePrompts: {
-        restartable: async () => assert.fail('incompatible Host used restart prompt'),
-        nonRestartable: async (_conflict, action) => {
-          prompts += 1;
-          assert.equal(action, 'replace_may_interrupt_work');
-          return 'replace';
-        },
-      },
+    { rootPath: '/workspace' } as DesktopRuntimeHostCandidateStartInput, {
+      startCandidate: async () => terminated ? ready(replacement.candidate) : conflict,
+      handoffSurface: decideHandoff((view) => {
+        assert.equal(terminated, false);
+        assert.ok(view.actions.includes('interrupt'));
+        return 'interrupt';
+      }),
       forceTerminateObservedHost: async (identity, authority) => {
-        terminations += 1;
-        assert.deepEqual(identity, {
-          rootPath: '/workspace',
-          registration: conflict.registration,
-        });
+        assert.deepEqual(identity, { rootPath: '/workspace', registration: conflict.registration });
         assert.deepEqual(authority.processIdentity, conflict.processIdentity);
         assert.equal(authority.isCurrent(), true);
+        terminated = true;
         return true;
       },
     },
   );
-
-  assert.equal(prompts, 1, 'even an idle snapshot must not authorize a forced stop');
-  assert.equal(terminations, 1);
-  assert.equal(starts, 2);
-  await owner.close();
-});
-
-test('silently replaces an idle non-restartable Local Host and retries', async () => {
-  const observed = upgradeRequired(true);
-  const conflict = {
-    ...observed,
-    restartable: false as const,
-    registration: { ...observed.registration, lifecycleMode: 'service' as const },
-  };
-  const replacement = candidateHarness();
-  let starts = 0;
-  let replaced: typeof observed.registration | undefined;
-  const policies: string[] = [];
-  const owner = await startRuntimeHostDesktopManager(
-    {} as DesktopRuntimeHostCandidateStartInput,
-    {
-      startCandidate: async () => {
-        starts += 1;
-        return starts === 1 ? conflict : ready(replacement.candidate);
-      },
-      upgradePrompts: {
-        restartable: async () => assert.fail('non-restartable conflict used restart prompt'),
-        nonRestartable: async () => assert.fail('idle replaceable Host must not prompt'),
-      },
-      resolveLocalHostReplacement: async (registration) => ({
-        replace: async (policy) => {
-          policies.push(policy);
-          replaced = registration;
-          return 'replaced';
-        },
-      }),
-    },
-  );
-  assert.equal(starts, 2);
-  assert.equal(replaced?.hostEpoch, conflict.registration.hostEpoch);
-  assert.deepEqual(policies, ['refuse_active_work']);
+  assert.equal(terminated, true);
   await owner.close();
 });
 
-test('prompts if a non-restartable Local Host omits its activity snapshot', async () => {
+test('cancelling a live handoff does not authorize any replacement', async () => {
   const observed = upgradeRequired(false);
-  const conflict = {
-    ...observed,
-    registration: { ...observed.registration, lifecycleMode: 'service' as const },
-  };
-  const replacement = candidateHarness();
-  const policies: string[] = [];
-  let starts = 0;
-  let prompts = 0;
-  const owner = await startRuntimeHostDesktopManager(
-    {} as DesktopRuntimeHostCandidateStartInput,
-    {
-      startCandidate: async () => {
-        starts += 1;
-        return starts === 1 ? conflict : ready(replacement.candidate);
-      },
-      upgradePrompts: {
-        restartable: async () => assert.fail('non-restartable conflict used restart prompt'),
-        nonRestartable: async (_conflict, action) => {
-          prompts += 1;
-          assert.equal(action, 'replace_may_interrupt_work');
-          return 'replace';
-        },
-      },
-      resolveLocalHostReplacement: async () => ({
-        replace: async (policy) => {
-          policies.push(policy);
-          return 'replaced';
-        },
-      }),
-    },
-  );
-
-  assert.equal(prompts, 1);
-  assert.equal(starts, 2);
-  assert.deepEqual(policies, ['interrupt_active_work']);
-  await owner.close();
-});
-
-test('prompts if an observed-idle Host becomes active before replacement', async () => {
-  const observed = upgradeRequired(true);
-  const conflict = {
-    ...observed,
-    restartable: false as const,
-    registration: { ...observed.registration, lifecycleMode: 'service' as const },
-  };
-  const replacement = candidateHarness();
-  const policies: string[] = [];
-  let starts = 0;
-  let prompts = 0;
-  const owner = await startRuntimeHostDesktopManager(
-    {} as DesktopRuntimeHostCandidateStartInput,
-    {
-      startCandidate: async () => {
-        starts += 1;
-        return starts === 1 ? conflict : ready(replacement.candidate);
-      },
-      upgradePrompts: {
-        restartable: async () => assert.fail('non-restartable conflict used restart prompt'),
-        nonRestartable: async (_conflict, action) => {
-          prompts += 1;
-          assert.equal(action, 'replace_may_interrupt_work');
-          return 'replace';
-        },
-      },
-      resolveLocalHostReplacement: async () => ({
-        replace: async (policy) => {
-          policies.push(policy);
-          return policy === 'refuse_active_work' ? 'active_tasks' : 'replaced';
-        },
-      }),
-    },
-  );
-
-  assert.equal(prompts, 1);
-  assert.equal(starts, 2);
-  assert.deepEqual(policies, ['refuse_active_work', 'interrupt_active_work']);
-  await owner.close();
-});
-
-test('does not authorize active-work interruption when replacement is cancelled', async () => {
-  const observed = upgradeRequired(false);
-  const conflict = {
-    ...observed,
-    registration: { ...observed.registration, lifecycleMode: 'service' as const },
-  };
-  const policies: string[] = [];
-
-  await assert.rejects(
-    startRuntimeHostDesktopManager({} as DesktopRuntimeHostCandidateStartInput, {
-      startCandidate: async () => conflict,
-      upgradePrompts: {
-        restartable: async () => assert.fail('non-restartable conflict used restart prompt'),
-        nonRestartable: async () => 'cancel',
-      },
-      resolveLocalHostReplacement: async () => ({
-        replace: async (policy) => {
-          policies.push(policy);
-          return 'active_tasks';
-        },
-      }),
-      onFatalError: () => undefined,
+  const conflict = { ...observed,
+    registration: { ...observed.registration, lifecycleMode: 'service' as const } };
+  await assert.rejects(startRuntimeHostDesktopManager({} as DesktopRuntimeHostCandidateStartInput, {
+    startCandidate: async () => conflict,
+    handoffSurface: decideHandoff(() => 'cancel'),
+    resolveLocalHostReplacement: async () => ({
+      canReplaceIdle: true,
+      replace: async () => assert.fail('cancel must not mutate the service'),
     }),
-    RuntimeHostUpgradeCancelledError,
-  );
-  assert.deepEqual(policies, []);
+    onFatalError: () => undefined,
+  }), RuntimeHostUpgradeCancelledError);
 });
 
-test('lets the user cancel startup when an incompatible Host owns the root', async () => {
-  const conflict = incompatibleHost('blocked_by_residency');
-  let presented: DesktopRuntimeHostCandidateStartResult | undefined;
-  await assert.rejects(
-    startRuntimeHostDesktopManager({} as DesktopRuntimeHostCandidateStartInput, {
-      startCandidate: async () => conflict,
-      upgradePrompts: {
-        restartable: async () => assert.fail('incompatible Host used restart prompt'),
-        nonRestartable: async (actual, action) => {
-          presented = actual;
-          assert.equal(action, 'wait');
-          return 'cancel';
-        },
-      },
-      onFatalError: () => undefined,
+test('keeps a known repair actionable when its first authority inspection fails', async () => {
+  const repaired = candidateHarness({ ownership: 'supervised' });
+  let inspected = false;
+  let didRepair = false;
+  let showedUnavailable = false;
+  const owner = await startRuntimeHostDesktopManager({} as DesktopRuntimeHostCandidateStartInput, {
+    startCandidate: async () => didRepair ? ready(repaired.candidate)
+      : { kind: 'failed', reason: 'deployment_needs_repair' },
+    resolveStartupRepair: async () => {
+      if (!inspected) {
+        inspected = true;
+        throw new Error('Authority inspection temporarily unavailable');
+      }
+      return {
+        identity: 'verified-repair', target: { name: 'Local', location: 'local' },
+        reason: 'repair', mayExitNaturally: false,
+        activity: { connections: 0, activeOperations: 0, processUptimeSeconds: 1, residencies: [] },
+        replacement: { kind: 'repair', canReplaceIdle: true, canInterrupt: false,
+          execute: async () => { didRepair = true; return { kind: 'completed' }; } },
+      };
+    },
+    handoffSurface: decideHandoff((view) => {
+      if (!showedUnavailable) {
+        assert.equal(didRepair, false);
+        assert.match(view.diagnostic ?? '', /Authority inspection temporarily unavailable/);
+        assert.deepEqual(view.actions, ['cancel', 'retry']);
+        showedUnavailable = true;
+      }
+      return 'retry';
     }),
-    (error: unknown) => {
-      assert.ok(error instanceof RuntimeHostUpgradeCancelledError);
-      assert.equal(error.message, 'Runtime Host restart was cancelled');
-      return true;
-    },
-  );
-  assert.equal(presented, conflict);
+  });
+  assert.equal(showedUnavailable, true);
+  assert.equal(didRepair, true);
+  await owner.close();
 });
 
+function decideHandoff(
+  choose: (view: HostHandoffView) => HostHandoffAction,
+): OpenHostHandoffSurface {
+  return (submit) => ({
+    update(view) { if (view.state === 'attention') submit(view.revision, choose(view)); },
+    close() {},
+  });
+}
+
 function incompatibleHost(
   replacement: 'wait_for_idle_exit' | 'blocked_by_residency',
 ): Extract<DesktopRuntimeHostCandidateStartResult, { kind: 'incompatible' }> {
diff --git a/apps/desktop/src/main/__tests__/runtime-host-local-operator.test.ts b/apps/desktop/src/main/__tests__/runtime-host-local-operator.test.ts
index 5a08954585..36aa3328e2 100644
--- a/apps/desktop/src/main/__tests__/runtime-host-local-operator.test.ts
+++ b/apps/desktop/src/main/__tests__/runtime-host-local-operator.test.ts
@@ -31,6 +31,7 @@ import {
   encodeRuntimeHostServiceManagementFrame,
   encodeRuntimeHostSetupFrame,
   RUNTIME_HOST_OPERATOR_PROJECT_DIRECTORY_CONFIGURATION_REQUEST_ENV,
+  RUNTIME_HOST_OPERATOR_RETIREMENT_CANCELLATION_ENV,
   RUNTIME_HOST_SETUP_SOURCE_PACKAGE_INTEGRITY_ENV,
 } from '@maka/runtime-host/operator';
 import {
@@ -45,6 +46,46 @@ const OPERATOR = {
   modulePath: '/tmp/maka/operator.mjs',
 };
 
+test('retirement cancellation sends EOF without terminating or abandoning the operator transaction', async (t) => {
+  const cancellation = new AbortController();
+  const child = new EventEmitter() as ReturnType<typeof spawn>;
+  const stdin = new PassThrough();
+  const stdout = new PassThrough();
+  const stderr = new PassThrough();
+  Object.assign(child, { pid: 1234, stdin, stdout, stderr });
+  let spawned!: () => void;
+  const started = new Promise<void>((resolve) => { spawned = resolve; });
+  const operator = createDesktopRuntimeHostLocalOperator({
+    spawnProcess: ((_command, _args, options) => {
+      assert.equal(options?.env?.[RUNTIME_HOST_OPERATOR_RETIREMENT_CANCELLATION_ENV], '1');
+      assert.deepEqual(options?.stdio, ['pipe', 'pipe', 'pipe']);
+      spawned();
+      return child;
+    }) as typeof spawn,
+    terminateProcess: async () => assert.fail('cancellation cannot kill the deployment transaction'),
+  });
+  t.after(() => operator.close());
+  let settled = false;
+  const result = operator.runService({
+    operator: OPERATOR, action: 'restart',
+    target: { serviceId: 'a'.repeat(64), rootId: 'a'.repeat(64), rootPath: '/tmp/maka/root' },
+    retirementSignal: cancellation.signal,
+  }).then((frame) => { settled = true; return frame; });
+  await started;
+  cancellation.abort();
+  await Promise.resolve();
+  assert.equal(stdin.writableEnded, true);
+  assert.equal(settled, false);
+  stdout.end(encodeRuntimeHostServiceManagementFrame({
+    schemaVersion: 1, kind: 'result', action: 'restart',
+    service: { platform: 'linux', arch: 'x64', osRelease: 'test', state: 'running',
+      pid: 42, lastExitCode: 0, installedVersion: '0.3.0', projectDirectoryRoots: [] },
+  }));
+  stderr.end();
+  child.emit('close', 0, null);
+  assert.equal((await result).kind, 'result');
+});
+
 test('local setup installs one managed service for the Desktop root with Direct peer enabled', () => {
   assert.deepEqual(
     runtimeHostLocalSetupCommand({
diff --git a/apps/desktop/src/main/__tests__/runtime-host-startup-recovery.test.ts b/apps/desktop/src/main/__tests__/runtime-host-startup-recovery.test.ts
deleted file mode 100644
index 8b8cc43a91..0000000000
--- a/apps/desktop/src/main/__tests__/runtime-host-startup-recovery.test.ts
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-import { runtimeHostStartupError } from "@maka/runtime-host/client";
-import { OperationalStateMigrationBlockedError } from '@maka/storage/operational-state-store';
-import { startDesktopRuntimeHostWithRecovery } from "../runtime-host-startup-recovery.js";
-
-test("repairs a managed Host once and resumes startup without asking the user", async () => {
-  let starts = 0;
-  const repairModes: Array<{
-    readonly allowManualUpdate: boolean;
-    readonly allowInterruptActiveTasks: boolean;
-  }> = [];
-  let prompts = 0;
-
-  const result = await startDesktopRuntimeHostWithRecovery({
-    start: async () => {
-      starts += 1;
-      if (starts === 1)
-        throw runtimeHostStartupError("managed_root_requires_operator");
-      return "ready";
-    },
-    repair: async (authority) => {
-      repairModes.push(authority);
-      return { kind: "repaired" };
-    },
-    prompt: async () => {
-      prompts += 1;
-      return "exit";
-    },
-  });
-
-  assert.equal(result, "ready");
-  assert.equal(starts, 2);
-  assert.deepEqual(repairModes, [
-    { allowManualUpdate: false, allowInterruptActiveTasks: false },
-  ]);
-  assert.equal(prompts, 0);
-});
-
-for (const failure of [
-  runtimeHostStartupError('managed_root_requires_operator'),
-  new OperationalStateMigrationBlockedError(new Error('Host migration required'), 'requires_host_migration'),
-]) test(`separates manual update consent from active-work interruption: ${failure.name}`, async () => {
-  let starts = 0;
-  const repairModes: Array<{
-    readonly allowManualUpdate: boolean;
-    readonly allowInterruptActiveTasks: boolean;
-  }> = [];
-  const prompts: boolean[] = [];
-
-  const result = await startDesktopRuntimeHostWithRecovery({
-    start: async () => {
-      starts += 1;
-      if (starts === 1)
-        throw failure;
-      return "ready";
-    },
-    repair: async (authority) => {
-      repairModes.push(authority);
-      if (!authority.allowManualUpdate) throw new Error("manual update confirmation required");
-      return authority.allowInterruptActiveTasks
-        ? { kind: "repaired" }
-        : { kind: "active_tasks" };
-    },
-    prompt: async (input) => {
-      prompts.push(input.activeTasks);
-      return "repair";
-    },
-  });
-
-  assert.equal(result, "ready");
-  assert.deepEqual(repairModes, [
-    { allowManualUpdate: false, allowInterruptActiveTasks: false },
-    { allowManualUpdate: true, allowInterruptActiveTasks: false },
-    { allowManualUpdate: true, allowInterruptActiveTasks: true },
-  ]);
-  assert.deepEqual(prompts, [false, true]);
-});
-
-for (const failure of [
-  new Error('renderer prerequisites failed'),
-  new OperationalStateMigrationBlockedError(new Error('unsupported newer schema')),
-]) test(`does not offer managed repair for an unrelated startup failure: ${failure.name}`, async () => {
-  let repairs = 0;
-  let prompts = 0;
-
-  await assert.rejects(
-    startDesktopRuntimeHostWithRecovery({
-      start: async () => {
-        throw failure;
-      },
-      repair: async () => {
-        repairs += 1;
-        return { kind: "repaired" };
-      },
-      prompt: async () => {
-        prompts += 1;
-        return "repair";
-      },
-    }),
-    failure,
-  );
-  assert.equal(repairs, 0);
-  assert.equal(prompts, 0);
-});
diff --git a/apps/desktop/src/main/__tests__/runtime-host-upgrade-dialog.test.ts b/apps/desktop/src/main/__tests__/runtime-host-upgrade-dialog.test.ts
deleted file mode 100644
index 9eea55398e..0000000000
--- a/apps/desktop/src/main/__tests__/runtime-host-upgrade-dialog.test.ts
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import { buildRuntimeHostUpgradeDialog } from '../runtime-host-upgrade-copy.js';
-import { createRuntimeHostUpgradePrompts } from '../runtime-host-upgrade-dialog.js';
-
-const conflict = {
-  kind: 'upgrade_required',
-  restartable: true,
-  registration: { pid: 42, lifecycleMode: 'ephemeral' },
-  handshake: {
-    activity: {
-      connections: 2,
-      activeOperations: 1,
-      processUptimeSeconds: 120,
-      residencies: [
-        { label: 'scheduled-task', count: 2 },
-        { label: 'daily-review', count: 1 },
-      ],
-    },
-  },
-} as unknown as Parameters<typeof buildRuntimeHostUpgradeDialog>[0];
-
-test('localizes upgrade activity without changing decision indexes', () => {
-  const en = buildRuntimeHostUpgradeDialog(
-    conflict,
-    'restart',
-    'en',
-  ).options;
-  const zh = buildRuntimeHostUpgradeDialog(
-    conflict,
-    'restart',
-    'zh-CN',
-  ).options;
-  const zhTw = buildRuntimeHostUpgradeDialog(
-    conflict,
-    'restart',
-    'zh-TW',
-  ).options;
-  assert.deepEqual(en.buttons, ['Restart Runtime Host', 'Wait', 'Cancel Startup']);
-  assert.deepEqual(zh.buttons, ['重启 Runtime Host', '等待', '取消启动']);
-  assert.equal(en.defaultId, en.cancelId);
-  assert.equal(zh.defaultId, zh.cancelId);
-  assert.match(zh.detail ?? '', /仍有 2 个其他客户端连接/);
-  assert.match(zh.detail ?? '', /每日回顾: 1/);
-  assert.match(en.detail ?? '', /Scheduled Task: 2/);
-  assert.match(zh.detail ?? '', /计划任务: 2/);
-  assert.deepEqual(zhTw.buttons, ['重啟 Runtime Host', '等待', '取消啟動']);
-  assert.match(zhTw.detail ?? '', /仍有 2 個其他客戶端連線/);
-  assert.match(zhTw.detail ?? '', /每日回顧: 1/);
-  assert.match(en.detail ?? '', /Process ID \(PID\):/);
-});
-
-test('maps the non-default replacement choice to the replace decision', async () => {
-  const prompts = createRuntimeHostUpgradePrompts(
-    async () => 'en',
-    async (options) => {
-      assert.deepEqual(options.buttons, ['Stop Host and Continue', 'Wait', 'Cancel Startup']);
-      assert.equal(options.defaultId, 2);
-      assert.equal(options.cancelId, 2);
-      assert.match(options.detail ?? '', /Maka will stop this Host/);
-      return { response: 0, checkboxChecked: false };
-    },
-  );
-  assert.equal(
-    await prompts.nonRestartable(
-      {
-        kind: 'upgrade_required',
-        restartable: false,
-        registration: { pid: 42, lifecycleMode: 'ephemeral' },
-      } as never,
-      'replace_may_interrupt_work',
-    ),
-    'replace',
-  );
-});
-
-test('defaults non-restartable prompts to cancellation', async () => {
-  const conflict = {
-    kind: 'upgrade_required',
-    restartable: false,
-    registration: { pid: 42, lifecycleMode: 'service' },
-  } as never;
-  const prompts = createRuntimeHostUpgradePrompts(
-    async () => 'en',
-    async (options) => {
-      assert.deepEqual(options.buttons, ['Cancel Startup']);
-      assert.equal(options.defaultId, 0);
-      assert.equal(options.cancelId, 0);
-      assert.doesNotMatch(options.detail ?? '', /If you wait/u);
-      return { response: 0, checkboxChecked: false };
-    },
-  );
-  assert.equal(
-    await prompts.nonRestartable(conflict, 'cancel_only'),
-    'cancel',
-  );
-
-  const waitDialog = buildRuntimeHostUpgradeDialog(
-    {
-      kind: 'upgrade_required',
-      restartable: false,
-      registration: { pid: 42, lifecycleMode: 'ephemeral' },
-    } as never,
-    'wait',
-    'en',
-  ).options;
-  assert.deepEqual(waitDialog.buttons, ['Wait', 'Cancel Startup']);
-  assert.equal(waitDialog.defaultId, waitDialog.cancelId);
-});
-
-test('does not offer passive waiting when a supervised Host can restart', async () => {
-  const prompts = createRuntimeHostUpgradePrompts(
-    async () => 'en',
-    async (options) => {
-      assert.deepEqual(options.buttons, ['Restart Runtime Host', 'Cancel Startup']);
-      assert.equal(options.defaultId, options.cancelId);
-      assert.doesNotMatch(options.detail ?? '', /If you wait/u);
-      return { response: 0, checkboxChecked: false };
-    },
-  );
-
-  assert.equal(
-    await prompts.restartable({
-      ...conflict,
-      registration: { pid: 42, lifecycleMode: 'service' },
-    } as never),
-    'restart',
-  );
-});
-
-test('explains when the safe replacement check could not verify idle state', () => {
-  const conflict = {
-    kind: 'upgrade_required' as const,
-    restartable: false as const,
-    registration: { pid: 42, lifecycleMode: 'service' as const },
-  } as Parameters<typeof buildRuntimeHostUpgradeDialog>[0];
-  const dialog = buildRuntimeHostUpgradeDialog(
-    conflict,
-    'replace_may_interrupt_work',
-    'zh-CN',
-  );
-
-  assert.match(dialog.options.detail ?? '', /无法确认此 Host 是否处于空闲状态/u);
-  assert.doesNotMatch(dialog.options.detail ?? '', /无法报告后台活动/u);
-  assert.equal(dialog.options.defaultId, dialog.options.cancelId);
-});
diff --git a/apps/desktop/src/main/__tests__/startup-progress-window.test.ts b/apps/desktop/src/main/__tests__/startup-progress-window.test.ts
index 728dde9b20..5ba94dd35b 100644
--- a/apps/desktop/src/main/__tests__/startup-progress-window.test.ts
+++ b/apps/desktop/src/main/__tests__/startup-progress-window.test.ts
@@ -21,6 +21,7 @@ import assert from 'node:assert/strict';
 import { EventEmitter } from 'node:events';
 import { test } from 'node:test';
 import type { BrowserWindow, BrowserWindowConstructorOptions } from 'electron';
+import type { HostHandoffView } from '@maka/runtime-host/client';
 import { createStartupProgressWindow, renderStartupProgressHtml } from '../startup-progress-window.js';
 
 function harness() {
@@ -30,6 +31,7 @@ function harness() {
   let minimized = false;
   let visible = false;
   let copied = 0;
+  let copiedHandoff: HostHandoffView | undefined;
   let documentUrl = '';
   let options: BrowserWindowConstructorOptions | undefined;
   let openWindow!: () => { action: string };
@@ -42,6 +44,7 @@ function harness() {
   const window = Object.assign(new EventEmitter(), {
     webContents: contents,
     setMenuBarVisibility() {},
+    setSize() {},
     isDestroyed: () => destroyed,
     isMinimized: () => minimized,
     destroy() { destroyed = true; },
@@ -61,13 +64,14 @@ function harness() {
   const progress = createStartupProgressWindow({
     locale: 'en', dark: false, icon: '/test/icon.png',
     createWindow(input) { options = input; return window as unknown as BrowserWindow; },
-    copyDiagnostics() { copied += 1; },
+    copyDiagnostics(_phase, handoff) { copied += 1; copiedHandoff = handoff; },
     onError(error) { errors.push(error); },
   });
   return {
     progress, window, contents, scripts, errors, resolveLoad, rejectLoad,
     get options() { return options; },
     get copied() { return copied; },
+    get copiedHandoff() { return copiedHandoff; },
     get documentUrl() { return documentUrl; },
     get destroyed() { return destroyed; },
     get minimized() { return minimized; },
@@ -152,3 +156,24 @@ test('localized progress stays self-contained, accessible and has no fabricated
     }
   }
 });
+
+test('live handoff accepts only current allowed actions and copies the current diagnosis', async () => {
+  const h = harness();
+  const actions: string[] = [];
+  const view: HostHandoffView = { revision: 'first', target: { name: 'local', location: 'local' },
+    state: 'attention', reason: 'busy', mayExitNaturally: false,
+    actions: ['cancel', 'retry', 'interrupt'], defaultAction: 'cancel', diagnostic: 'current host is busy' };
+  const submit = (revision: string, action: string) => { actions.push(`${revision}:${action}`); };
+  h.progress.handoff(view, submit, 'en');
+  h.resolveLoad(); await flush();
+  h.progress.handoff({ ...view, revision: 'second', state: 'progress', phase: 'pausing', actions: ['cancel'] }, submit, 'en');
+  for (const url of ['maka-startup://handoff/first/interrupt', 'maka-startup://handoff/second/interrupt',
+    'maka-startup://handoff/second/cancel', 'maka-startup://copy']) {
+    h.contents.emit('will-navigate', { preventDefault() {} }, url);
+  }
+  await flush();
+  assert.deepEqual(actions, ['second:cancel']);
+  assert.equal(h.copiedHandoff?.revision, 'second');
+  assert.equal(h.copiedHandoff?.diagnostic, view.diagnostic);
+  h.progress.close();
+});
diff --git a/apps/desktop/src/main/native-diagnostic-dialog-copy.ts b/apps/desktop/src/main/native-diagnostic-dialog-copy.ts
index bd9ccee1eb..522033559c 100644
--- a/apps/desktop/src/main/native-diagnostic-dialog-copy.ts
+++ b/apps/desktop/src/main/native-diagnostic-dialog-copy.ts
@@ -39,16 +39,6 @@ interface NativeDiagnosticDialogCopy {
     readonly recover: string;
     readonly exit: string;
   };
-  readonly runtimeHostRecovery: {
-    readonly title: string;
-    readonly message: string;
-    readonly detail: string;
-    readonly activeTasks: string;
-    readonly repairFailed: string;
-    readonly repair: string;
-    readonly repairAndRestart: string;
-    readonly exit: string;
-  };
   readonly defaultRuntimeHostRecovery: {
     readonly title: string;
     connectFailed(profileName: string): string;
@@ -88,18 +78,6 @@ const COPY = {
       recover: 'Recover Interface',
       exit: 'Exit',
     },
-    runtimeHostRecovery: {
-      title: 'Maka needs to repair Runtime Host',
-      message: 'The Runtime Host for this workspace could not start.',
-      detail:
-        'Maka can repair the managed Runtime Host selected by this Desktop. Your workspace, Host identity, credentials, and settings will be preserved. Repair may replace the installed Host with the version selected for this Desktop even when automatic update compatibility cannot be confirmed.',
-      activeTasks:
-        'The Host may still own active work. Continuing can interrupt that work before the Host restarts.',
-      repairFailed: 'The previous repair attempt did not finish. Copy diagnostics to inspect the details.',
-      repair: 'Repair Runtime Host',
-      repairAndRestart: 'Repair and Restart Host',
-      exit: 'Exit',
-    },
     defaultRuntimeHostRecovery: {
       title: 'Default Runtime Host is unavailable',
       connectFailed: (profileName) => `Could not connect to ${profileName}`,
@@ -138,17 +116,6 @@ const COPY = {
       recover: '恢复界面',
       exit: '退出',
     },
-    runtimeHostRecovery: {
-      title: 'Maka 需要修复 Runtime Host',
-      message: '管理此工作区的 Runtime Host 无法启动。',
-      detail:
-        'Maka 可以修复此 Desktop 选择的托管 Runtime Host。工作区、Host 身份、凭证和设置都会保留。即使无法确认自动更新兼容性,修复也可能使用此 Desktop 选择的版本替换当前 Host。',
-      activeTasks: 'Host 可能仍有正在运行的任务。继续会先中断这些任务,再重启 Host。',
-      repairFailed: '上一次修复未能完成。复制诊断信息可查看详情。',
-      repair: '修复 Runtime Host',
-      repairAndRestart: '修复并重启 Host',
-      exit: '退出',
-    },
     defaultRuntimeHostRecovery: {
       title: '默认 Runtime Host 无法连接',
       connectFailed: (profileName) => `无法连接 ${profileName}`,
@@ -187,17 +154,6 @@ const COPY = {
       recover: '復原介面',
       exit: '退出',
     },
-    runtimeHostRecovery: {
-      title: 'Maka 需要修復 Runtime Host',
-      message: '管理此工作區的 Runtime Host 無法啟動。',
-      detail:
-        'Maka 可以修復此 Desktop 選擇的受管理 Runtime Host。工作區、Host 身分、認證資料和設定都會保留。即使無法確認自動更新相容性,修復也可能使用此 Desktop 選擇的版本取代目前 Host。',
-      activeTasks: 'Host 可能仍有正在執行的任務。繼續會先中斷這些任務,再重新啟動 Host。',
-      repairFailed: '上一次修復未能完成。複製診斷資訊可檢視詳細資料。',
-      repair: '修復 Runtime Host',
-      repairAndRestart: '修復並重新啟動 Host',
-      exit: '退出',
-    },
     defaultRuntimeHostRecovery: {
       title: '預設 Runtime Host 無法連線',
       connectFailed: (profileName) => `無法連線至 ${profileName}`,
diff --git a/apps/desktop/src/main/native-diagnostic-dialog.ts b/apps/desktop/src/main/native-diagnostic-dialog.ts
index 231c30a2e1..7106a45240 100644
--- a/apps/desktop/src/main/native-diagnostic-dialog.ts
+++ b/apps/desktop/src/main/native-diagnostic-dialog.ts
@@ -44,11 +44,6 @@ interface FatalStartupDiagnosticDialogDeps {
   readonly showMessageBox: (options: MessageBoxOptions) => Promise<MessageBoxReturnValue>;
 }
 
-export interface RuntimeHostStartupRecoveryDialogInput {
-  readonly startupError: Error;
-  readonly repairError?: Error;
-  readonly activeTasks: boolean;
-}
 
 export function defaultRuntimeHostRecoveryDialog(input: {
   readonly locale: UiLocale;
@@ -143,33 +138,6 @@ export async function showMainRendererProcessGoneDialog(
   return result.response === 0 ? 'recover' : 'exit';
 }
 
-export async function showRuntimeHostStartupRecoveryDialog(
-  input: RuntimeHostStartupRecoveryDialogInput,
-  deps: DiagnosticDialogDeps,
-): Promise<'repair' | 'exit'> {
-  const copy = getNativeDiagnosticDialogCopy(deps.locale).runtimeHostRecovery;
-  const detail = [
-    copy.detail,
-    input.activeTasks ? copy.activeTasks : undefined,
-    input.repairError ? copy.repairFailed : undefined,
-  ]
-    .filter(Boolean)
-    .join('\n\n');
-  const result = await showMessageBoxWithDiagnostics(
-    {
-      type: 'warning',
-      title: copy.title,
-      message: copy.message,
-      detail,
-      buttons: [input.activeTasks ? copy.repairAndRestart : copy.repair, copy.exit],
-      defaultId: input.activeTasks || input.repairError ? 1 : 0,
-      cancelId: 1,
-      noLink: true,
-    },
-    deps,
-  );
-  return result.response === 0 ? 'repair' : 'exit';
-}
 
 async function copyDiagnostics(
   copy: () => void | Promise<void>,
diff --git a/apps/desktop/src/main/runtime-host-boot.ts b/apps/desktop/src/main/runtime-host-boot.ts
index db1b353f0c..a7eb2f5ed2 100644
--- a/apps/desktop/src/main/runtime-host-boot.ts
+++ b/apps/desktop/src/main/runtime-host-boot.ts
@@ -134,7 +134,6 @@ import {
   defaultRuntimeHostRecoveryDialog,
   showMainRendererProcessGoneDialog,
   showMessageBoxWithDiagnostics,
-  showRuntimeHostStartupRecoveryDialog,
 } from "./native-diagnostic-dialog.js";
 import { getNativeDiagnosticDialogCopy } from "./native-diagnostic-dialog-copy.js";
 import {
@@ -188,16 +187,11 @@ import {
   startRuntimeHostDesktopManager,
   type RuntimeHostDesktopManager,
 } from "./runtime-host-desktop-manager.js";
-import {
-  canRepairManagedRuntimeHostStartup,
-  DesktopRuntimeHostStartupRecoveryCancelledError,
-  startDesktopRuntimeHostWithRecovery,
-} from "./runtime-host-startup-recovery.js";
 import {
   buildRuntimeHostActiveQuitDialog,
 } from "./runtime-host-quit-copy.js";
 import { prepareRuntimeHostQuit } from "./runtime-host-quit.js";
-import { createRuntimeHostUpgradePrompts } from "./runtime-host-upgrade-dialog.js";
+import { createDesktopHostHandoffSurface } from './startup-presentation.js';
 import { registerRuntimeHostMemoryIpc } from "./runtime-host-memory-ipc-main.js";
 import {
   createDesktopRuntimeHostProfileService,
@@ -1137,10 +1131,7 @@ const startLocalRuntimeHostManager = () => startRuntimeHostDesktopManager(
       runtimeHostProfileService.resolveCollaborationConnectionTarget(profile),
   },
   {
-    upgradePrompts: createRuntimeHostUpgradePrompts(
-      () => desktopLocale.resolve(),
-      showStartupDiagnosticDialog,
-    ),
+    handoffSurface: createDesktopHostHandoffSurface(() => desktopLocale.resolve()),
     onTargetStateChanged: (state) => {
       const profileAccess = runtimeHostProfileAccess(state.target.profile);
       const hostId = state.readiness === "ready"
@@ -1236,14 +1227,10 @@ const startLocalRuntimeHostManager = () => startRuntimeHostDesktopManager(
       });
     },
     recoverLocalHost: (signal) => localRuntimeHostRemoteAccess.recoverBeforeLocalHostStart(signal),
+    resolveStartupRepair: (error, signal) => localRuntimeHostRemoteAccess.resolveStartupRepair(error, signal),
     resolveLocalHostReplacement: (registration, signal) =>
       localRuntimeHostRemoteAccess.resolveConflictingHostReplacement(registration, signal),
     onFatalError: (error, target) => {
-      if (
-        !runtimeHostManager &&
-        target.profile.kind === "local" &&
-        canRepairManagedRuntimeHostStartup(error)
-      ) return;
       if (error instanceof RuntimeHostUpgradeCancelledError) {
         if (target.profile.kind === "local") app.quit();
         return;
@@ -1253,51 +1240,9 @@ const startLocalRuntimeHostManager = () => startRuntimeHostDesktopManager(
     },
   },
 );
-runtimeHostManager = await startDesktopRuntimeHostWithRecovery({
-  start: async () => {
-    updateDesktopStartupProgress('connect');
-    await localRuntimeHostRemoteAccess.recoverBeforeLocalHostStart();
-    return startLocalRuntimeHostManager();
-  },
-  repair: async ({ allowManualUpdate, allowInterruptActiveTasks }) => {
-    updateDesktopStartupProgress('package');
-    console.warn('[runtime-host] repairing the managed Local Host before startup');
-    const result = await localRuntimeHostRemoteAccess.repairManagedStartup({
-      allowManualUpdate,
-      allowInterruptActiveTasks,
-    });
-    console.log(`[runtime-host] managed Local Host repair result: ${result.kind}`);
-    return result;
-  },
-  prompt: async (input) => {
-    updateDesktopStartupProgress('attention');
-    console.error('[runtime-host] managed Local Host startup recovery requires attention:', {
-      startupError: input.startupError,
-      repairError: input.repairError,
-      activeTasks: input.activeTasks,
-    });
-    const locale = await desktopLocale.resolve();
-    return showRuntimeHostStartupRecoveryDialog(input, {
-      locale,
-      showMessageBox: (options) => showDesktopMessageBox(options, { locale }),
-      copyDiagnostics: () =>
-        copyDesktopDiagnosticReport(
-          desktopDiagnostics,
-          createDesktopStartupDiagnosticInput({
-            title: 'Runtime Host startup recovery',
-            description: input.startupError.message,
-            details: [input.startupError.stack, input.repairError?.stack]
-              .filter(Boolean)
-              .join('\n\n'),
-          }),
-        ),
-    });
-  },
-}).catch((error: unknown) => {
-  if (
-    error instanceof RuntimeHostUpgradeCancelledError ||
-    error instanceof DesktopRuntimeHostStartupRecoveryCancelledError
-  ) {
+updateDesktopStartupProgress('connect');
+runtimeHostManager = await startLocalRuntimeHostManager().catch((error: unknown) => {
+  if (error instanceof RuntimeHostUpgradeCancelledError) {
     app.quit();
     return new Promise<never>(() => undefined);
   }
diff --git a/apps/desktop/src/main/runtime-host-client.ts b/apps/desktop/src/main/runtime-host-client.ts
index 7abc9327e4..cc7aa35e1a 100644
--- a/apps/desktop/src/main/runtime-host-client.ts
+++ b/apps/desktop/src/main/runtime-host-client.ts
@@ -160,7 +160,7 @@ const decodeStoredMessage = (value: unknown): StoredMessage =>
 const MAX_OPTIMISTIC_ATTEMPTS = 3;
 const MAX_SESSION_REVISION_ATTEMPTS = 8;
 const MAX_PRICING_SNAPSHOT_ATTEMPTS = 3;
-const RUNTIME_HOST_RETIREMENT_TIMEOUT_MS = 5_000;
+const RUNTIME_HOST_RETIREMENT_TIMEOUT_MS = 15_000;
 
 export type DesktopSessionConfigurationPatch = SessionConfigurationPatch;
 
diff --git a/apps/desktop/src/main/runtime-host-desktop-manager.ts b/apps/desktop/src/main/runtime-host-desktop-manager.ts
index a053213e32..db9a709858 100644
--- a/apps/desktop/src/main/runtime-host-desktop-manager.ts
+++ b/apps/desktop/src/main/runtime-host-desktop-manager.ts
@@ -21,9 +21,17 @@ import { randomUUID } from 'node:crypto';
 import type { BotIncomingMessage } from '@maka/runtime/bots';
 import {
   abortable,
+  connectExistingRuntimeHost,
+  prepareConnectedRuntimeHostRetirement,
+  runHostHandoff,
+  HostHandoffCancelledError,
+  type OpenHostHandoffSurface,
+  type HostHandoffObservation,
+  type HostHandoffBlocker,
   forceTerminateObservedRegisteredRuntimeHost,
   RuntimeHostOperationError,
   RuntimeHostPermanentReconnectError,
+  RuntimeHostRemoteCompatibilityError,
   RuntimeHostPeerError,
   RuntimeHostRequestInterruptedError,
   runtimeHostStartupError,
@@ -39,7 +47,7 @@ import {
   type RuntimeHostSshInteraction,
 } from '@maka/runtime-host/client';
 import {
-  isHostActivityIdle,
+  RUNTIME_HOST_PROTOCOL_VERSION,
   type HostRegistration,
   type HostStatusResult,
 } from '@maka/runtime-host/protocol';
@@ -53,6 +61,7 @@ import {
 } from './runtime-host-desktop-candidate.js';
 import { RuntimeHostReconnectingIpcMain } from './runtime-host-reconnecting-ipc-main.js';
 import { RuntimeHostSessionObservationRegistry } from './runtime-host-session-observation-registry.js';
+import { canRepairManagedRuntimeHostStartup } from './runtime-host-startup-recovery.js';
 
 export interface RuntimeHostDesktopManager {
   current(profileId?: string): RuntimeHostDesktopTargetSnapshot | undefined;
@@ -172,15 +181,14 @@ export class DesktopLocalHostRetirementError extends Error {
   }
 }
 
-export type RuntimeHostRestartDecision = 'restart' | 'wait' | 'cancel';
-export type RuntimeHostNonRestartableDecision = 'replace' | 'wait' | 'cancel';
-export type RuntimeHostNonRestartableAction =
-  | 'replace_may_interrupt_work'
-  | 'wait'
-  | 'cancel_only';
-
 export interface RuntimeHostLocalReplacement {
-  replace(activeWorkPolicy: RuntimeHostRetirementMode): Promise<'replaced' | 'active_tasks'>;
+  readonly identity?: string;
+  readonly canReplaceIdle?: boolean;
+  replace(
+    activeWorkPolicy: RuntimeHostRetirementMode,
+    progress?: (phase: 'checking' | 'staging' | 'retiring' | 'replacing') => void,
+    signal?: AbortSignal,
+  ): Promise<'replaced' | 'active_tasks'>;
 }
 
 export class RuntimeHostUpgradeCancelledError extends RuntimeHostPermanentReconnectError {
@@ -214,16 +222,6 @@ export type RuntimeHostWaitConflict =
     >
   | Extract<DesktopRuntimeHostCandidateStartResult, { kind: 'incompatible' }>;
 
-export interface RuntimeHostUpgradePrompts {
-  restartable(
-    conflict: RuntimeHostRestartableConflict,
-  ): Promise<RuntimeHostRestartDecision>;
-  nonRestartable(
-    conflict: RuntimeHostWaitConflict,
-    action: RuntimeHostNonRestartableAction,
-  ): Promise<RuntimeHostNonRestartableDecision>;
-}
-
 interface DesktopRuntimeHostTargetGeneration {
   readonly epoch: string;
   readonly input: DesktopRuntimeHostCandidateStartInput;
@@ -257,18 +255,15 @@ export async function startRuntimeHostDesktopManager(
       observationRegistry: RuntimeHostSessionObservationRegistry,
     ) => Promise<DesktopRuntimeHostCandidateStartResult>;
     onFatalError?: (error: Error, target: ResolvedRuntimeHostProfile) => void;
-    upgradePrompts?: RuntimeHostUpgradePrompts;
+    handoffSurface?: OpenHostHandoffSurface;
     waitForHostExit?: (pid: number) => Promise<void>;
     forceTerminateObservedHost?: typeof forceTerminateObservedRegisteredRuntimeHost;
-    waitForHostRetirement?: (
-      registration: HostRegistration,
-      signal: AbortSignal,
-    ) => Promise<void>;
     resolveLocalHostReplacement?: (
       registration: HostRegistration,
       signal: AbortSignal,
     ) => Promise<RuntimeHostLocalReplacement | undefined>;
     recoverLocalHost?: (signal: AbortSignal) => Promise<boolean>;
+    resolveStartupRepair?: (error: Error, signal: AbortSignal) => Promise<HostHandoffBlocker | undefined>;
     reconnectBackoff?: RuntimeHostReconnectBackoff;
     pairingFinalizationTimeoutMs?: number;
     onTargetStateChanged?: (state: RuntimeHostDesktopTargetState) => void;
@@ -281,12 +276,12 @@ export async function startRuntimeHostDesktopManager(
     input,
     options.startCandidate ?? startDesktopRuntimeHostCandidate,
     options.onFatalError ?? ((error) => console.error('[runtime-host] reconnect failed:', error)),
-    options.upgradePrompts,
+    options.handoffSurface,
     options.waitForHostExit ?? waitForProcessExit,
     options.forceTerminateObservedHost ?? forceTerminateObservedRegisteredRuntimeHost,
-    options.waitForHostRetirement ?? waitForProcessRetirement,
     options.resolveLocalHostReplacement,
     options.recoverLocalHost,
+    options.resolveStartupRepair,
     options.reconnectBackoff,
     options.pairingFinalizationTimeoutMs ?? DEFAULT_PAIRING_FINALIZATION_TIMEOUT_MS,
     options.onTargetStateChanged,
@@ -320,13 +315,9 @@ class RuntimeHostDesktopManagerImpl implements RuntimeHostDesktopManager {
       error: Error,
       target: ResolvedRuntimeHostProfile,
     ) => void,
-    private readonly upgradePrompts: RuntimeHostUpgradePrompts | undefined,
+    private readonly handoffSurface: OpenHostHandoffSurface | undefined,
     private readonly waitForHostExit: (pid: number) => Promise<void>,
     private readonly forceTerminateObservedHost: typeof forceTerminateObservedRegisteredRuntimeHost,
-    private readonly waitForHostRetirement: (
-      registration: HostRegistration,
-      signal: AbortSignal,
-    ) => Promise<void>,
     private readonly resolveLocalHostReplacement:
       | ((
           registration: HostRegistration,
@@ -336,6 +327,9 @@ class RuntimeHostDesktopManagerImpl implements RuntimeHostDesktopManager {
     private readonly recoverLocalHost:
       | ((signal: AbortSignal) => Promise<boolean>)
       | undefined,
+    private readonly resolveStartupRepair:
+      | ((error: Error, signal: AbortSignal) => Promise<HostHandoffBlocker | undefined>)
+      | undefined,
     private readonly reconnectBackoff: RuntimeHostReconnectBackoff | undefined,
     private readonly pairingFinalizationTimeoutMs: number,
     private readonly onTargetStateChanged:
@@ -1036,7 +1030,6 @@ class RuntimeHostDesktopManagerImpl implements RuntimeHostDesktopManager {
     sshInteraction: RuntimeHostSshInteraction | undefined,
     onConnectionPhase: ((phase: RuntimeHostConnectionPhase) => void) | undefined,
   ): Promise<DesktopRuntimeHostCandidate> {
-    let takeoverHostEpoch: string | undefined;
     let localRecoveryAttempted = false;
     const inheritedExit = target.input.onExit;
     let refreshPeerRoutes = target.skipPeerRouteRefreshOnce !== true;
@@ -1048,6 +1041,26 @@ class RuntimeHostDesktopManagerImpl implements RuntimeHostDesktopManager {
       localRecoveryAttempted = true;
       return this.recoverLocalHost(signal);
     };
+    const resolveRepair = async (error: unknown): Promise<HostHandoffObservation<DesktopRuntimeHostCandidate> | undefined> => {
+      if (target.input.profileTarget || !(error instanceof Error) ||
+        !canRepairManagedRuntimeHostStartup(error) || !this.resolveStartupRepair) return undefined;
+      let blocker: HostHandoffBlocker | undefined;
+      let diagnostic = error.message;
+      try {
+        blocker = await this.resolveStartupRepair(error, signal);
+      } catch (inspectionError) {
+        signal.throwIfAborted();
+        // The repair need is known; unavailable authority evidence must not
+        // grant replacement rights or discard the live Retry/Cancel journey.
+        diagnostic += '\n' + (inspectionError instanceof Error ? inspectionError.message : String(inspectionError));
+      }
+      return { kind: 'blocked', blocker: blocker ?? {
+        identity: JSON.stringify([target.epoch, error.name, diagnostic]),
+        target: { name: target.target.profile.name, location: 'local' },
+        reason: 'repair', mayExitNaturally: false, diagnostic,
+      } };
+    };
+    const observe = async (): Promise<HostHandoffObservation<DesktopRuntimeHostCandidate>> => {
     while (true) {
       let result: DesktopRuntimeHostCandidateStartResult;
       const ipcMain = this.#ipcMain.createTarget(target.epoch);
@@ -1073,14 +1086,24 @@ class RuntimeHostDesktopManagerImpl implements RuntimeHostDesktopManager {
             onConnectionPhase: (phase) => onConnectionPhase?.(phase),
             ...(refreshPeerRoutes ? {} : { refreshPeerRoutes: false }),
             signal,
-            ...(takeoverHostEpoch === undefined ? {} : { takeoverHostEpoch }),
           },
           target.observations,
         );
         refreshPeerRoutes = true;
       } catch (error) {
         signal.throwIfAborted();
+        if (target.input.profileTarget && error instanceof RuntimeHostRemoteCompatibilityError) {
+          return { kind: 'blocked', blocker: {
+            identity: JSON.stringify([target.epoch, error.hostEpoch, error.details]),
+            target: { name: target.target.profile.name, location: 'remote',
+              ...(target.target.profile.kind === 'local' ? {} : { rootId: target.target.profile.rootId }),
+              hostEpoch: error.hostEpoch },
+            reason: 'upgrade', mayExitNaturally: false, diagnostic: error.message,
+          } };
+        }
         if (await tryRecoverLocalHost()) continue;
+        const repair = await resolveRepair(error);
+        if (repair) return repair;
         throw error;
       }
       if (result.kind === 'ready') {
@@ -1105,81 +1128,97 @@ class RuntimeHostDesktopManagerImpl implements RuntimeHostDesktopManager {
               ? { ownedProcess: retainedOwnedProcess }
               : {}),
         };
-        return result.candidate;
-      }
-      if (result.kind === 'upgrade_required' && result.restartable) {
-        const activity = result.handshake?.activity;
-        const decision =
-          activity && isHostActivityIdle(activity)
-            ? 'restart'
-            : await this.#resolveRestartable(result);
-        if (decision === 'cancel') {
-          throw new RuntimeHostUpgradeCancelledError();
-        }
-        if (decision === 'restart') {
-          takeoverHostEpoch = result.registration.hostEpoch;
-          continue;
-        }
-        takeoverHostEpoch = undefined;
-        await this.waitForHostRetirement(result.registration, signal);
-        continue;
+        return { kind: 'ready', value: result.candidate };
       }
-      if (
-        result.kind === 'incompatible' ||
-        (result.kind === 'upgrade_required' && !result.restartable)
-      ) {
+      if (result.kind === 'incompatible' || result.kind === 'upgrade_required') {
+        const conflict = result;
+        const idleTakeover = result.kind === 'upgrade_required' && result.restartable &&
+          !target.input.profileTarget && target.input.generation !== undefined;
+        const cooperativeRetirement = !target.input.profileTarget &&
+          result.registration.lifecycleMode === 'ephemeral' &&
+          result.handshake?.activity?.cooperativeHandoff === true;
         const replacement = target.input.profileTarget
           ? undefined
           : this.#registeredEphemeralHostReplacement(target, result, signal) ??
             (await this.resolveLocalHostReplacement?.(result.registration, signal));
-        const activity = result.handshake?.activity;
-        if (replacement && activity && isHostActivityIdle(activity)) {
-          // Only a complete, observed snapshot can authorize silent
-          // replacement. The replacement transaction closes races with new
-          // operations; an absent snapshot requires explicit consent because
-          // it cannot prove that other clients are disconnected.
-          const attempt = await replacement.replace('refuse_active_work');
-          if (attempt === 'replaced') {
-            takeoverHostEpoch = undefined;
-            continue;
-          }
-        }
-        // The retirement waiter observes a local PID. Remote targets cannot
-        // use it to prove that a Host on another machine has exited.
-        const action: RuntimeHostNonRestartableAction = replacement
-          ? 'replace_may_interrupt_work'
-          : target.input.profileTarget
-            ? 'cancel_only'
-            : 'wait';
-        const decision = await this.#resolveNonRestartable(result, action);
-        if (decision === 'cancel') throw new RuntimeHostUpgradeCancelledError();
-        if (decision === 'replace') {
-          if (!replacement) {
-            throw new RuntimeHostPermanentReconnectError(
-              'This Runtime Host cannot be replaced from the current target',
-            );
-          }
-          const replaced = await replacement.replace('interrupt_active_work');
-          if (replaced === 'active_tasks') {
-            throw new RuntimeHostPermanentReconnectError(
-              'This Runtime Host still owns work that cannot be interrupted safely',
-            );
-          }
-          takeoverHostEpoch = undefined;
-          continue;
-        }
-        takeoverHostEpoch = undefined;
-        await this.waitForHostRetirement(result.registration, signal);
-        continue;
+        return { kind: 'blocked', blocker: {
+          identity: JSON.stringify([target.epoch, result.registration, result.processIdentity, replacement?.identity]),
+          target: {
+            name: target.target.profile.name,
+            location: target.input.profileTarget ? 'remote' : 'local',
+            rootId: result.registration.rootId,
+            hostEpoch: result.registration.hostEpoch,
+          },
+          reason: 'upgrade',
+          ...(result.handshake?.activity ? { activity: result.handshake.activity } : {}),
+          mayExitNaturally: result.registration.lifecycleMode === 'ephemeral' &&
+            result.handshake?.replacement === 'wait_for_idle_exit',
+          ...((replacement || idleTakeover || cooperativeRetirement) ? { replacement: {
+            kind: 'replace',
+            canReplaceIdle: result.handshake?.state === 'ready' &&
+              (cooperativeRetirement || idleTakeover || replacement?.canReplaceIdle === true),
+            canInterrupt: replacement !== undefined,
+            execute: async (policy, progress, _consent, attemptSignal) => {
+              const retirementSignal = attemptSignal ? AbortSignal.any([signal, attemptSignal]) : signal;
+              retirementSignal.throwIfAborted();
+              progress('retiring');
+              if (policy === 'refuse_active_work' && cooperativeRetirement) {
+                const observed = await connectExistingRuntimeHost({
+                  rootPath: target.input.rootPath,
+                  protocol: { min: RUNTIME_HOST_PROTOCOL_VERSION, max: RUNTIME_HOST_PROTOCOL_VERSION },
+                  compositionId: conflict.registration.compositionId,
+                });
+                if (observed.kind !== 'connected') return { kind: 'changed' };
+                try {
+                  if (observed.registration.rootId !== conflict.registration.rootId ||
+                    observed.registration.hostEpoch !== conflict.registration.hostEpoch ||
+                    !observed.connection.cooperativeHandoff) return { kind: 'changed' };
+                  const prepared = await prepareConnectedRuntimeHostRetirement(
+                    observed.connection, policy, 60_000, retirementSignal,
+                  );
+                  return { kind: prepared.kind === 'prepared' ? 'completed' : 'active_work' };
+                } finally {
+                  await observed.connection.close();
+                }
+              }
+              if (policy === 'refuse_active_work' && idleTakeover) {
+                const retired = await connectExistingRuntimeHost({
+                  rootPath: target.input.rootPath,
+                  protocol: { min: RUNTIME_HOST_PROTOCOL_VERSION, max: RUNTIME_HOST_PROTOCOL_VERSION },
+                  compositionId: conflict.registration.compositionId,
+                  generation: target.input.generation,
+                  takeoverHostEpoch: conflict.registration.hostEpoch,
+                });
+                if (retired.kind === 'connected') await retired.connection.close();
+                if (retired.kind === 'draining') return { kind: 'completed' };
+                return { kind: 'registration' in retired &&
+                  retired.registration?.hostEpoch === conflict.registration.hostEpoch ? 'active_work' : 'changed' };
+              }
+              if (!replacement) return { kind: 'changed' };
+              const replaced = await replacement.replace(policy, progress, retirementSignal);
+              return { kind: replaced === 'replaced' ? 'completed' : 'active_work' };
+            },
+          } } : {}),
+        } };
       }
       if (await tryRecoverLocalHost()) continue;
-      throw runtimeHostStartupError(result.reason, result.diagnostic);
+      const failure = runtimeHostStartupError(result.reason, result.diagnostic);
+      const repair = await resolveRepair(failure);
+      if (repair) return repair;
+      throw failure;
+    }
+    };
+    try {
+      return await runHostHandoff({ observe, openSurface: this.handoffSurface, signal });
+    } catch (error) {
+      if (error instanceof HostHandoffCancelledError) throw new RuntimeHostUpgradeCancelledError();
+      throw error;
     }
   }
 
   #registeredEphemeralHostReplacement(
     target: DesktopRuntimeHostTargetGeneration,
-    conflict: RuntimeHostWaitConflict,
+    conflict: RuntimeHostWaitConflict | RuntimeHostRestartableConflict,
     signal: AbortSignal,
   ): RuntimeHostLocalReplacement | undefined {
     const { registration, processIdentity } = conflict;
@@ -1190,18 +1229,20 @@ class RuntimeHostDesktopManagerImpl implements RuntimeHostDesktopManager {
       target.valid &&
       this.#targets.get(target.target.profile.id) === target;
     return {
-      replace: async (activeWorkPolicy) => {
+      canReplaceIdle: false,
+      replace: async (activeWorkPolicy, _progress, attemptSignal) => {
         // This Host cannot participate in the current retirement protocol, so
         // an earlier idle snapshot cannot prove that it remains idle. Require
         // explicit consent before using the identity-fenced termination path.
         if (activeWorkPolicy === 'refuse_active_work') return 'active_tasks';
         signal.throwIfAborted();
+        attemptSignal?.throwIfAborted();
         const terminated = await this.forceTerminateObservedHost(
           {
             rootPath: this.#baseInput.rootPath,
             registration,
           },
-          { processIdentity, isCurrent: stillAuthorized },
+          { processIdentity, isCurrent: () => stillAuthorized() && !attemptSignal?.aborted },
         );
         signal.throwIfAborted();
         if (!terminated) {
@@ -1214,27 +1255,6 @@ class RuntimeHostDesktopManagerImpl implements RuntimeHostDesktopManager {
     };
   }
 
-  #resolveRestartable(
-    conflict: RuntimeHostRestartableConflict,
-  ): Promise<RuntimeHostRestartDecision> {
-    if (this.upgradePrompts) return this.upgradePrompts.restartable(conflict);
-    return this.#missingUpgradePrompt();
-  }
-
-  #resolveNonRestartable(
-    conflict: RuntimeHostWaitConflict,
-    action: RuntimeHostNonRestartableAction,
-  ): Promise<RuntimeHostNonRestartableDecision> {
-    if (this.upgradePrompts) return this.upgradePrompts.nonRestartable(conflict, action);
-    return this.#missingUpgradePrompt();
-  }
-
-  #missingUpgradePrompt(): never {
-    throw new RuntimeHostPermanentReconnectError(
-      'An older Runtime Host is still running. Restart it or wait for its background work to finish.',
-    );
-  }
-
   #requireLifecycle(
     target: DesktopRuntimeHostTargetGeneration,
   ): RuntimeHostReconnectLifecycle<DesktopRuntimeHostCandidate> {
@@ -1488,30 +1508,6 @@ function isSessionGuestProfile(
   return profile.kind === 'remote' && profile.access === 'session_guest';
 }
 
-function waitForAbortableDelay(ms: number, signal: AbortSignal): Promise<void> {
-  if (signal.aborted) return Promise.reject(signal.reason);
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      signal.removeEventListener('abort', onAbort);
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(signal.reason);
-    };
-    signal.addEventListener('abort', onAbort, { once: true });
-  });
-}
-
-async function waitForProcessRetirement(
-  registration: HostRegistration,
-  signal: AbortSignal,
-): Promise<void> {
-  while (isProcessAlive(registration.pid)) {
-    await waitForAbortableDelay(250, signal);
-  }
-}
-
 async function waitForProcessExit(pid: number): Promise<void> {
   // The Host owns a 10-second graceful-shutdown deadline. Keep a separate
   // observation margin so Desktop cannot race the Host's final process.exit.
diff --git a/apps/desktop/src/main/runtime-host-local-operator.ts b/apps/desktop/src/main/runtime-host-local-operator.ts
index 1ade55cedc..8f42ae890d 100644
--- a/apps/desktop/src/main/runtime-host-local-operator.ts
+++ b/apps/desktop/src/main/runtime-host-local-operator.ts
@@ -28,6 +28,7 @@ import {
 } from '@maka/runtime/process-tree-terminator';
 import {
   decodeRuntimeHostAccessManagementFrame,
+  RUNTIME_HOST_OPERATOR_RETIREMENT_CANCELLATION_ENV,
   decodeRuntimeHostPeerManagementFrame,
   decodeRuntimeHostPeerMeshManagementFrame,
   decodeRuntimeHostServiceManagementFrame,
@@ -126,6 +127,7 @@ export interface DesktopRuntimeHostLocalSetupCommand {
 }
 
 export interface DesktopRuntimeHostLocalServiceManagementInput {
+  readonly retirementSignal?: AbortSignal;
   readonly operator: RuntimeHostOperatorCommand;
   readonly action:
     | 'status'
@@ -139,6 +141,7 @@ export interface DesktopRuntimeHostLocalServiceManagementInput {
   readonly target: DesktopRuntimeHostLocalServiceTarget;
   readonly projectDirectoryRoots?: readonly { readonly label: string; readonly path: string }[];
   readonly expectedConfigFingerprint?: string;
+  readonly expectedHost?: { readonly hostEpoch: string; readonly pid: number };
   readonly allowInterruptActiveTasks?: boolean;
   readonly retainManagedDeployment?: boolean;
   readonly signal?: AbortSignal;
@@ -235,6 +238,7 @@ export function createDesktopRuntimeHostLocalOperator(input: {
   ): Promise<RuntimeHostServiceManagementFrame>;
   runUpdate(
     input: {
+      readonly retirementSignal?: AbortSignal;
       readonly setupPackage: DesktopRuntimeHostSetupPackage;
       readonly target: DesktopRuntimeHostLocalServiceTarget;
       readonly expectedHost?: { readonly hostEpoch: string; readonly pid: number };
@@ -421,6 +425,7 @@ export function createDesktopRuntimeHostLocalOperator(input: {
             ...(command.expectedConfigFingerprint
               ? ['--expected-config-fingerprint', command.expectedConfigFingerprint]
               : []),
+            ...(command.expectedHost ? ['--expected-host-json', JSON.stringify(command.expectedHost)] : []),
             ...(command.allowInterruptActiveTasks ? ['--allow-interrupt-active-tasks'] : []),
             ...(command.retainManagedDeployment ? ['--retain-managed-deployment'] : []),
             ...managedTargetArgs(command.target),
@@ -436,6 +441,7 @@ export function createDesktopRuntimeHostLocalOperator(input: {
         timeoutMs: input.setupTimeoutMs ?? SETUP_TIMEOUT_MS,
         terminate,
         signal: combinedSignal(command.signal, closing.signal),
+        retirementSignal: command.retirementSignal,
         active,
       }).then((frame) => requireServiceFrame(frame, command.action));
     },
@@ -482,6 +488,7 @@ export function createDesktopRuntimeHostLocalOperator(input: {
         timeoutMs: input.setupTimeoutMs ?? SETUP_TIMEOUT_MS,
         terminate,
         signal: combinedSignal(command.signal, closing.signal),
+        retirementSignal: command.retirementSignal,
         active,
         action: 'update',
         onProgress,
@@ -620,6 +627,7 @@ function requireServiceFrame(
 }
 
 function runServiceFrameProcess(input: {
+  readonly retirementSignal?: AbortSignal;
   readonly command: DesktopRuntimeHostLocalSetupCommand;
   readonly environment: NodeJS.ProcessEnv;
   readonly spawnProcess: typeof spawn;
@@ -790,6 +798,7 @@ function managedTargetArgs(target: DesktopRuntimeHostLocalServiceTarget): string
 }
 
 function runSingleFrameProcess<Frame>(input: {
+  readonly retirementSignal?: AbortSignal;
   readonly command: DesktopRuntimeHostLocalSetupCommand;
   readonly prefix: string;
   readonly decode: (line: string) => Frame | undefined;
@@ -866,6 +875,7 @@ function runSetupProcess(input: {
 }
 
 async function runFramedProcess<Frame, Result>(input: {
+  readonly retirementSignal?: AbortSignal;
   readonly command: DesktopRuntimeHostLocalSetupCommand;
   readonly cwd?: string;
   readonly prefix: string;
@@ -886,6 +896,7 @@ async function runFramedProcess<Frame, Result>(input: {
 }): Promise<Result> {
   const deadline = Date.now() + input.timeoutMs;
   input.signal?.throwIfAborted();
+  input.retirementSignal?.throwIfAborted();
   const lookupTimeoutMs = deadline - Date.now();
   if (lookupTimeoutMs <= 0) throw new Error(`${input.label} timed out`);
   const command = await resolveLocalNpmCommand(
@@ -902,12 +913,19 @@ async function runFramedProcess<Frame, Result>(input: {
     const child = input.spawnProcess(command.executable, [...command.args], {
       ...(input.cwd ? { cwd: input.cwd } : {}),
       detached: process.platform !== 'win32',
-      env: input.environment,
-      stdio: [input.inputLine === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe'],
+      env: { ...input.environment, ...(input.retirementSignal
+        ? { [RUNTIME_HOST_OPERATOR_RETIREMENT_CANCELLATION_ENV]: '1' } : {}) },
+      stdio: [input.inputLine === undefined && !input.retirementSignal ? 'ignore' : 'pipe', 'pipe', 'pipe'],
       windowsHide: true,
     });
     input.active.add(child);
     if (input.inputLine !== undefined) child.stdin?.end(`${input.inputLine}\n`);
+    const cancelRetirement = () => { child.stdin?.end(); };
+    // EOF is a cooperative request, not permission to kill the lifecycle owner.
+    // Old operators may ignore it; their final transaction result is still awaited.
+    child.stdin?.on('error', () => undefined);
+    input.retirementSignal?.addEventListener('abort', cancelRetirement, { once: true });
+    if (input.retirementSignal?.aborted) cancelRetirement();
     let filterFailure: Error | undefined;
     let stopFailure: Error | undefined;
     let stderr = '';
@@ -931,6 +949,7 @@ async function runFramedProcess<Frame, Result>(input: {
     const cleanup = () => {
       clearTimeout(timeout);
       input.signal?.removeEventListener('abort', onAbort);
+      input.retirementSignal?.removeEventListener('abort', cancelRetirement);
       input.active.delete(child);
     };
     const finish = (result: Result | undefined, error?: Error) => {
diff --git a/apps/desktop/src/main/runtime-host-local-remote-access.ts b/apps/desktop/src/main/runtime-host-local-remote-access.ts
index 214a0f7d77..4f9a3fd861 100644
--- a/apps/desktop/src/main/runtime-host-local-remote-access.ts
+++ b/apps/desktop/src/main/runtime-host-local-remote-access.ts
@@ -25,6 +25,8 @@ import type { IpcMain } from 'electron';
 import {
   encodeRuntimeHostOwnerConnectionCode,
   issueRuntimeHostOwnerConnectionCode,
+  connectExistingRuntimeHost,
+  type HostHandoffBlocker,
 } from '@maka/runtime-host/client';
 import {
   createRuntimeHostLegacyPosixOperatorCommand,
@@ -34,7 +36,7 @@ import {
   type RuntimeHostOperatorCommand,
   type RuntimeHostServiceUpdatePhase,
 } from '@maka/runtime-host/operator';
-import type { HostPeerEndpoint, HostRegistration } from '@maka/runtime-host/protocol';
+import { RUNTIME_HOST_PROTOCOL_VERSION, type HostActivitySnapshot, type HostPeerEndpoint, type HostRegistration } from '@maka/runtime-host/protocol';
 import type {
   DesktopLocalRuntimeHostRemoteAccessEnableResult,
   DesktopLocalRuntimeHostRemoteAccessSnapshot,
@@ -131,10 +133,17 @@ export interface DesktopLocalRuntimeHostRemoteAccess {
     registration: HostRegistration,
     signal: AbortSignal,
   ): Promise<RuntimeHostLocalReplacement | undefined>;
+  resolveStartupRepair(error: Error, signal: AbortSignal): Promise<HostHandoffBlocker | undefined>;
   repairManagedStartup(input?: {
+    readonly retirementSignal?: AbortSignal;
     readonly allowManualUpdate?: boolean;
     readonly allowInterruptActiveTasks?: boolean;
     readonly signal?: AbortSignal;
+    readonly onProgress?: (phase: RuntimeHostServiceUpdatePhase | 'restart') => void;
+    readonly expected?: {
+      readonly lifecycle: DesktopRuntimeHostLocalManagementTarget;
+      readonly host?: HostRegistration;
+    };
   }): Promise<DesktopRuntimeHostManagedStartupRepairResult>;
   recoverBeforeLocalHostStart(signal?: AbortSignal): Promise<boolean>;
   recover(): Promise<void>;
@@ -187,6 +196,7 @@ export function createDesktopLocalRuntimeHostRemoteAccess(input: {
   readonly resolveManagedDeploymentAuthority?: (
     rootId: string,
   ) => Promise<LocalManagedDeploymentAuthority | undefined>;
+  readonly inspectHost?: typeof connectExistingRuntimeHost;
 }): DesktopLocalRuntimeHostRemoteAccess {
   const lifecyclePath = join(input.clientDataRoot, LIFECYCLE_FILE);
   const closing = new AbortController();
@@ -708,7 +718,7 @@ export function createDesktopLocalRuntimeHostRemoteAccess(input: {
   input.ipcMain.handle(channels[3], revokeSharedAccess);
   input.ipcMain.handle(channels[4], disable);
 
-  return {
+  const service: DesktopLocalRuntimeHostRemoteAccess = {
     getSnapshot,
     createCollaborationConnectionTarget,
     enable,
@@ -746,10 +756,14 @@ export function createDesktopLocalRuntimeHostRemoteAccess(input: {
       }
       const target = authority.target;
       return {
-        replace: (activeWorkPolicy) =>
+        identity: JSON.stringify(target),
+        canReplaceIdle: true,
+        replace: (activeWorkPolicy, progress, retirementSignal) =>
           serialize(async () => {
             signal.throwIfAborted();
-            const setupPackage = await input.resolveSetupPackage(signal);
+            retirementSignal?.throwIfAborted();
+            const setupPackage = await input.resolveSetupPackage(retirementSignal
+              ? AbortSignal.any([signal, retirementSignal]) : signal);
             const frame = await input.operator.runUpdate(
               {
                 setupPackage,
@@ -762,8 +776,12 @@ export function createDesktopLocalRuntimeHostRemoteAccess(input: {
                   ? { allowInterruptActiveTasks: true }
                   : {}),
                 signal,
+                ...(retirementSignal ? { retirementSignal } : {}),
+              },
+              (phase) => {
+                input.onUpdateProgress?.(phase);
+                progress?.(phase);
               },
-              (phase) => input.onUpdateProgress?.(phase),
             );
             if (frame.kind === 'error') {
               if (frame.error.code === 'active_tasks') return 'active_tasks';
@@ -789,31 +807,100 @@ export function createDesktopLocalRuntimeHostRemoteAccess(input: {
           }),
       };
     },
+    resolveStartupRepair: async (error, signal) => {
+      const lifecycle = await readLifecycle(lifecyclePath, input.rootPath, input.rootId);
+      if (lifecycle?.state !== 'managed') return undefined;
+      const authority = await resolveManagedDeploymentAuthority(input.rootId);
+      const observed = await (input.inspectHost ?? connectExistingRuntimeHost)({
+        rootPath: input.rootPath,
+        protocol: { min: RUNTIME_HOST_PROTOCOL_VERSION, max: RUNTIME_HOST_PROTOCOL_VERSION },
+      });
+      const registration = 'registration' in observed ? observed.registration : undefined;
+      let activity: HostActivitySnapshot | undefined;
+      if (observed.kind === 'connected') {
+        try {
+          const facts = await observed.connection.request('host.diagnostics.query', {});
+          if (facts.hostEpoch === observed.connection.hostEpoch && facts.pid === observed.registration.pid &&
+            facts.state === 'ready' && facts.connections >= 1 && facts.activeOperations >= 1) {
+            // The accepted diagnostic connection and query are our own, not work
+            // requiring consent. Legacy residency evidence stays conservative.
+            activity = { connections: facts.connections - 1, activeOperations: facts.activeOperations - 1,
+              processUptimeSeconds: facts.processUptimeSeconds, residencies: facts.residencies,
+              ...(observed.connection.cooperativeHandoff ? { cooperativeHandoff: true } : {}) };
+          }
+        } catch { /* Missing activity evidence never authorizes automatic interruption. */ }
+        finally { await observed.connection.close(); }
+      } else if (observed.kind === 'incompatible' || observed.kind === 'upgrade_required') {
+        if (observed.handshake?.state === 'ready') activity = observed.handshake.activity;
+      }
+      signal.throwIfAborted();
+      const identity = JSON.stringify([lifecycle, authority, registration]);
+      return {
+        identity,
+        target: { name: hostname(), location: 'local', rootId: input.rootId,
+          ...(registration ? { hostEpoch: registration.hostEpoch } : {}) },
+        reason: 'repair', mayExitNaturally: false,
+        ...(activity ? { activity } : {}),
+        diagnostic: error.message,
+        replacement: {
+          kind: 'repair', canReplaceIdle: true, canInterrupt: registration !== undefined,
+          execute: async (policy, progress, consent, retirementSignal) => {
+            retirementSignal?.throwIfAborted();
+            const current = await readLifecycle(lifecyclePath, input.rootPath, input.rootId);
+            const currentAuthority = await resolveManagedDeploymentAuthority(input.rootId);
+            if (JSON.stringify([current, currentAuthority, registration]) !== identity) return { kind: 'changed' };
+            progress('staging');
+            const result = await service.repairManagedStartup({
+              allowManualUpdate: consent === 'explicit',
+              allowInterruptActiveTasks: policy === 'interrupt_active_work',
+              signal,
+              ...(retirementSignal ? { retirementSignal } : {}),
+              onProgress: (phase) => progress(phase === 'restart' ? 'replacing' : phase),
+              expected: { lifecycle, ...(registration ? { host: registration } : {}) },
+            });
+            return { kind: result.kind === 'repaired' ? 'completed' : result.kind === 'active_tasks' ? 'active_work' : 'changed' };
+          },
+        },
+      };
+    },
     repairManagedStartup: (options = {}) =>
       serialize(async () => {
         const signal = options.signal
           ? AbortSignal.any([options.signal, closing.signal])
           : closing.signal;
         signal.throwIfAborted();
+        options.retirementSignal?.throwIfAborted();
         const lifecycle = await readLifecycle(lifecyclePath, input.rootPath, input.rootId);
         if (lifecycle?.state !== 'managed') return { kind: 'unavailable' };
+        if (options.expected && JSON.stringify(lifecycle) !== JSON.stringify(options.expected.lifecycle)) {
+          return { kind: 'unavailable' };
+        }
 
         const setupPackage = await input.resolveSetupPackage(signal);
-        input.onUpdateProgress?.('checking');
+        const progress = (phase: RuntimeHostServiceUpdatePhase | 'restart') => {
+          input.onUpdateProgress?.(phase);
+          options.onProgress?.(phase);
+        };
+        progress('checking');
         const frame = await input.operator.runUpdate(
           {
             setupPackage,
             target: lifecycle,
+            ...(options.expected?.host ? { expectedHost: {
+              hostEpoch: options.expected.host.hostEpoch, pid: options.expected.host.pid,
+            } } : {}),
             ...(options.allowManualUpdate ? { allowManualUpdate: true } : {}),
             ...(options.allowInterruptActiveTasks
               ? { allowInterruptActiveTasks: true }
               : {}),
             signal,
+            ...(options.retirementSignal ? { retirementSignal: options.retirementSignal } : {}),
           },
-          (phase) => input.onUpdateProgress?.(phase),
+          (phase) => progress(phase),
         );
         if (frame.kind === 'error') {
           if (frame.error.code === 'active_tasks') return { kind: 'active_tasks' };
+          if (frame.error.code === 'target_mismatch') return { kind: 'unavailable' };
           throw new Error(`Runtime Host repair failed: ${frame.error.message}`);
         }
         if (frame.kind === 'progress' || frame.action !== 'update') {
@@ -822,18 +909,23 @@ export function createDesktopLocalRuntimeHostRemoteAccess(input: {
         if (frame.update.kind === 'active_tasks') return { kind: 'active_tasks' };
 
         if (frame.update.kind === 'already_current') {
-          input.onUpdateProgress?.('restart');
+          progress('restart');
           const restarted = await input.operator.runService({
             operator: lifecycle.operator,
             action: 'restart',
             target: lifecycle,
+            ...(options.expected?.host ? { expectedHost: {
+              hostEpoch: options.expected.host.hostEpoch, pid: options.expected.host.pid,
+            } } : {}),
             ...(options.allowInterruptActiveTasks
               ? { allowInterruptActiveTasks: true }
               : {}),
             signal,
+            ...(options.retirementSignal ? { retirementSignal: options.retirementSignal } : {}),
           });
           if (restarted.kind === 'error') {
             if (restarted.error.code === 'active_tasks') return { kind: 'active_tasks' };
+            if (restarted.error.code === 'target_mismatch') return { kind: 'unavailable' };
             throw new Error(`Runtime Host restart failed: ${restarted.error.message}`);
           }
           if (restarted.kind === 'progress' || restarted.action !== 'restart') {
@@ -912,6 +1004,7 @@ export function createDesktopLocalRuntimeHostRemoteAccess(input: {
       await mutation;
     },
   };
+  return service;
 }
 
 function conflictReplacementError(pid: number, reason: string): Error {
diff --git a/apps/desktop/src/main/runtime-host-startup-recovery.ts b/apps/desktop/src/main/runtime-host-startup-recovery.ts
index 5d68697609..7455116f05 100644
--- a/apps/desktop/src/main/runtime-host-startup-recovery.ts
+++ b/apps/desktop/src/main/runtime-host-startup-recovery.ts
@@ -20,106 +20,6 @@
 import { RuntimeHostStartupError } from "@maka/runtime-host/client";
 import { OperationalStateMigrationBlockedError } from '@maka/storage/operational-state-store';
 
-export type DesktopRuntimeHostStartupRepairResult =
-  | { readonly kind: "repaired" }
-  | { readonly kind: "active_tasks" }
-  | { readonly kind: "unavailable" };
-
-export interface DesktopRuntimeHostStartupRecoveryPrompt {
-  readonly startupError: Error;
-  readonly repairError?: Error;
-  readonly activeTasks: boolean;
-}
-
-export interface DesktopRuntimeHostStartupRepairAuthority {
-  readonly allowManualUpdate: boolean;
-  readonly allowInterruptActiveTasks: boolean;
-}
-
-export class DesktopRuntimeHostStartupRecoveryCancelledError extends Error {
-  readonly name = "DesktopRuntimeHostStartupRecoveryCancelledError";
-
-  constructor(options?: ErrorOptions) {
-    super("Runtime Host startup recovery was cancelled", options);
-  }
-}
-
-export async function startDesktopRuntimeHostWithRecovery<T>(input: {
-  readonly start: () => Promise<T>;
-  readonly repair: (
-    authority: DesktopRuntimeHostStartupRepairAuthority,
-  ) => Promise<DesktopRuntimeHostStartupRepairResult>;
-  readonly prompt: (
-    input: DesktopRuntimeHostStartupRecoveryPrompt,
-  ) => Promise<"repair" | "exit">;
-}): Promise<T> {
-  let startupError: Error;
-  try {
-    return await input.start();
-  } catch (error) {
-    startupError = asError(error);
-    if (!canRepairManagedRuntimeHostStartup(startupError)) throw startupError;
-  }
-
-  let activeTasks = false;
-  let repairError: Error | undefined;
-  let automatic: DesktopRuntimeHostStartupRepairResult | undefined;
-  try {
-    automatic = await input.repair({
-      allowManualUpdate: false,
-      allowInterruptActiveTasks: false,
-    });
-  } catch (error) {
-    repairError = asError(error);
-  }
-  if (automatic?.kind === "unavailable") throw startupError;
-  if (automatic?.kind === "active_tasks") activeTasks = true;
-  if (automatic?.kind === "repaired") {
-    try {
-      return await input.start();
-    } catch (error) {
-      startupError = asError(error);
-      if (!canRepairManagedRuntimeHostStartup(startupError)) throw startupError;
-    }
-  }
-
-  for (;;) {
-    const decision = await input.prompt({
-      startupError,
-      ...(repairError ? { repairError } : {}),
-      activeTasks,
-    });
-    if (decision === "exit") {
-      throw new DesktopRuntimeHostStartupRecoveryCancelledError({
-        cause: startupError,
-      });
-    }
-
-    let repaired: DesktopRuntimeHostStartupRepairResult;
-    try {
-      repaired = await input.repair({
-        allowManualUpdate: true,
-        allowInterruptActiveTasks: activeTasks,
-      });
-    } catch (error) {
-      repairError = asError(error);
-      continue;
-    }
-    if (repaired.kind === "unavailable") throw startupError;
-    if (repaired.kind === "active_tasks") {
-      activeTasks = true;
-      repairError = undefined;
-      continue;
-    }
-    try {
-      return await input.start();
-    } catch (error) {
-      startupError = asError(error);
-      if (!canRepairManagedRuntimeHostStartup(startupError)) throw startupError;
-      repairError = undefined;
-    }
-  }
-}
 
 export function canRepairManagedRuntimeHostStartup(error: Error): boolean {
   if (error instanceof OperationalStateMigrationBlockedError) {
@@ -135,7 +35,3 @@ export function canRepairManagedRuntimeHostStartup(error: Error): boolean {
       error.reason === "deployment_needs_repair")
   );
 }
-
-function asError(error: unknown): Error {
-  return error instanceof Error ? error : new Error(String(error));
-}
diff --git a/apps/desktop/src/main/runtime-host-upgrade-copy.ts b/apps/desktop/src/main/runtime-host-upgrade-copy.ts
deleted file mode 100644
index e08d2574cd..0000000000
--- a/apps/desktop/src/main/runtime-host-upgrade-copy.ts
+++ /dev/null
@@ -1,212 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-import type { UiLocale } from '@maka/core/ui-locale';
-import type { MessageBoxOptions } from 'electron';
-import type {
-  RuntimeHostNonRestartableAction,
-  RuntimeHostRestartableConflict,
-  RuntimeHostWaitConflict,
-} from './runtime-host-desktop-manager.js';
-
-type Conflict = RuntimeHostRestartableConflict | RuntimeHostWaitConflict;
-export type RuntimeHostUpgradeDialogDecision = 'restart' | 'replace' | 'wait' | 'cancel';
-
-type RuntimeHostUpgradeAvailability = RuntimeHostNonRestartableAction | 'restart';
-
-export interface RuntimeHostUpgradeDialog {
-  readonly options: MessageBoxOptions;
-  readonly decisions: readonly RuntimeHostUpgradeDialogDecision[];
-}
-type ActivityKey =
-  | 'goal'
-  | 'scheduledTask'
-  | 'dailyReview'
-  | 'execution'
-  | 'resource'
-  | 'graph'
-  | 'other';
-
-export function buildRuntimeHostUpgradeDialog(
-  conflict: Conflict,
-  availability: RuntimeHostUpgradeAvailability,
-  locale: UiLocale,
-): RuntimeHostUpgradeDialog {
-  const copy = UPGRADE_COPY[locale];
-  const choices: { readonly label: string; readonly decision: RuntimeHostUpgradeDialogDecision }[] =
-    [];
-  const action =
-    availability === 'restart'
-      ? 'restart'
-      : availability === 'replace_may_interrupt_work'
-        ? 'replace'
-        : undefined;
-  const canWait =
-    availability === 'wait' ||
-    (availability === 'restart' && conflict.registration.lifecycleMode !== 'service') ||
-    (availability === 'replace_may_interrupt_work' &&
-      conflict.registration.lifecycleMode === 'ephemeral');
-  if (action) {
-    choices.push({
-      label: action === 'restart' ? copy.restart : copy.replace,
-      decision: action,
-    });
-  }
-  if (canWait) choices.push({ label: copy.wait, decision: 'wait' });
-  choices.push({ label: copy.cancel, decision: 'cancel' });
-  const cancelId = choices.length - 1;
-  return {
-    options: {
-      type: 'warning',
-      title: copy.title,
-      message: copy.message,
-      detail: formatActivity(conflict, availability, canWait, locale),
-      buttons: choices.map((choice) => choice.label),
-      defaultId: cancelId,
-      cancelId,
-      noLink: true,
-    },
-    decisions: choices.map((choice) => choice.decision),
-  };
-}
-
-function formatActivity(
-  conflict: Conflict,
-  availability: RuntimeHostUpgradeAvailability,
-  canWait: boolean,
-  locale: UiLocale,
-): string {
-  const activity = conflict.handshake?.activity;
-  const copy = UPGRADE_COPY[locale];
-  const lines: string[] = [];
-  lines.push(copy.processId(conflict.registration.pid));
-  if (activity) {
-    const minutes = Math.max(1, Math.round(activity.processUptimeSeconds / 60));
-    lines.push(copy.uptime(minutes));
-    if (activity.connections > 0) lines.push(copy.connections(activity.connections));
-    if (activity.activeOperations > 0) lines.push(copy.operations(activity.activeOperations));
-    for (const residency of activity.residencies) {
-      lines.push(`${copy.activity[activityKey(residency.label)]}: ${residency.count}`);
-    }
-  } else if (availability === 'replace_may_interrupt_work') {
-    lines.push(copy.idleNotVerified);
-  } else lines.push(copy.unknownActivity);
-  if (availability === 'replace_may_interrupt_work') {
-    lines.push('', copy.replaceWarning, copy.replaceExplanation);
-  } else if (availability === 'restart') {
-    lines.push('', copy.restartWarning);
-  } else if (conflict.kind !== 'upgrade_required' || !conflict.restartable) {
-    lines.push('');
-    lines.push(copy.exitOwner(conflict.registration.pid));
-  }
-  if (canWait) {
-    lines.push(copy.waitExplanation);
-  }
-  return lines.join('\n');
-}
-
-function activityKey(label: string): ActivityKey {
-  const keys: Record<string, ActivityKey> = {
-    goal: 'goal',
-    'scheduled-task': 'scheduledTask',
-    'daily-review': 'dailyReview',
-    'hosted-execution': 'execution',
-    'runtime-resource': 'resource',
-    'agent-graph': 'graph',
-    'agent-graph-supervisor': 'graph',
-  };
-  return keys[label] ?? 'other';
-}
-
-const UPGRADE_COPY = {
-  en: {
-    title: 'Older Runtime Host is running',
-    message: 'Another Runtime Host process still owns this workspace.',
-    restart: 'Restart Runtime Host',
-    replace: 'Stop Host and Continue',
-    wait: 'Wait',
-    cancel: 'Cancel Startup',
-    uptime: (n: number) => `Running for about ${n} ${n === 1 ? 'minute' : 'minutes'}`,
-    connections: (n: number) => `${n} other client(s) are still connected`,
-    operations: (n: number) => `${n} operation(s) are running`,
-    idleNotVerified: 'Maka could not verify that this Host is idle during the safe replacement check.',
-    unknownActivity: 'This Host version cannot report its background activity.',
-    processId: (pid: number) => `Process ID (PID): ${pid}`,
-    restartWarning:
-      'Restarting preserves durable state, but it can interrupt in-flight external work.',
-    replaceWarning:
-      'Stopping preserves durable state, but it can interrupt in-flight external work.',
-    replaceExplanation: 'Maka will stop this Host, replace it safely, and continue startup.',
-    exitOwner: (pid: number) =>
-      `End process ${pid} with your system process manager to replace this Host safely.`,
-    waitExplanation: 'If you wait, Maka will continue automatically when this Host exits.',
-    activity: {
-      goal: 'Goal', scheduledTask: 'Scheduled Task', dailyReview: 'Daily Review',
-      execution: 'Active execution', resource: 'Runtime resource', graph: 'Agent Graph',
-      other: 'Other background activity',
-    },
-  },
-  'zh-CN': {
-    title: '旧版 Runtime Host 正在运行',
-    message: '另一个 Runtime Host 进程仍占用此工作区。',
-    restart: '重启 Runtime Host',
-    replace: '停止 Host 并继续',
-    wait: '等待',
-    cancel: '取消启动',
-    uptime: (n: number) => `已运行约 ${n} 分钟`,
-    connections: (n: number) => `仍有 ${n} 个其他客户端连接`,
-    operations: (n: number) => `有 ${n} 个操作正在运行`,
-    idleNotVerified: '安全替换检查无法确认此 Host 是否处于空闲状态。',
-    unknownActivity: '此 Host 版本无法报告后台活动。',
-    processId: (pid: number) => `进程 ID (PID):${pid}`,
-    restartWarning: '重启会保留持久化状态,但可能中断正在进行的外部工作。',
-    replaceWarning: '停止 Host 会保留持久化状态,但可能中断正在进行的外部工作。',
-    replaceExplanation: 'Maka 将停止并安全替换此 Host,然后继续启动。',
-    exitOwner: (pid: number) =>
-      `请使用系统进程管理工具结束进程 ${pid},以便安全替换此 Host。`,
-    waitExplanation: '若选择等待,当前 Host 退出后 Maka 将自动继续。',
-    activity: {
-      goal: '目标', scheduledTask: '计划任务', dailyReview: '每日回顾', execution: '活动执行',
-      resource: 'Runtime 资源', graph: 'Agent Graph', other: '其他后台活动',
-    },
-  },
-  'zh-TW': {
-    title: '舊版 Runtime Host 正在執行',
-    message: '另一個 Runtime Host 程序仍佔用此工作區。',
-    restart: '重啟 Runtime Host',
-    replace: '停止 Host 並繼續',
-    wait: '等待',
-    cancel: '取消啟動',
-    uptime: (n: number) => `已執行約 ${n} 分鐘`,
-    connections: (n: number) => `仍有 ${n} 個其他客戶端連線`,
-    operations: (n: number) => `有 ${n} 個操作正在執行`,
-    idleNotVerified: '安全替換檢查無法確認此 Host 是否處於閒置狀態。',
-    unknownActivity: '此 Host 版本無法報告後臺活動。',
-    processId: (pid: number) => `程序 ID (PID):${pid}`,
-    restartWarning: '重啟會保留持久化狀態,但可能中斷正在進行的外部工作。',
-    replaceWarning: '停止 Host 會保留持久化狀態,但可能中斷正在進行的外部工作。',
-    replaceExplanation: 'Maka 將停止並安全替換此 Host,然後繼續啟動。',
-    exitOwner: (pid: number) => `請使用系統程序管理工具結束程序 ${pid},以便安全替換此 Host。`,
-    waitExplanation: '若選擇等待,目前 Host 退出後 Maka 將自動繼續。',
-    activity: {
-      goal: '目標', scheduledTask: '計劃任務', dailyReview: '每日回顧', execution: '活動執行',
-      resource: 'Runtime 資源', graph: 'Agent Graph', other: '其他後臺活動',
-    },
-  },
-} as const;
diff --git a/apps/desktop/src/main/runtime-host-upgrade-dialog.ts b/apps/desktop/src/main/runtime-host-upgrade-dialog.ts
deleted file mode 100644
index 488307dc13..0000000000
--- a/apps/desktop/src/main/runtime-host-upgrade-dialog.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-import type { UiLocale } from '@maka/core/ui-locale';
-import type { MessageBoxOptions, MessageBoxReturnValue } from 'electron';
-import type {
-  RuntimeHostRestartDecision,
-  RuntimeHostUpgradePrompts,
-  RuntimeHostNonRestartableDecision,
-} from './runtime-host-desktop-manager.js';
-import { buildRuntimeHostUpgradeDialog } from './runtime-host-upgrade-copy.js';
-
-export function createRuntimeHostUpgradePrompts(
-  resolveLocale: () => Promise<UiLocale>,
-  showDialog: (
-    options: MessageBoxOptions,
-    locale: UiLocale,
-  ) => Promise<MessageBoxReturnValue>,
-): RuntimeHostUpgradePrompts {
-  return {
-    restartable: async (conflict): Promise<RuntimeHostRestartDecision> => {
-      const locale = await resolveLocale();
-      const dialog = buildRuntimeHostUpgradeDialog(conflict, 'restart', locale);
-      const { response } = await showDialog(
-        dialog.options,
-        locale,
-      );
-      const decision = dialog.decisions[response] ?? 'cancel';
-      return decision === 'restart' || decision === 'wait' ? decision : 'cancel';
-    },
-    nonRestartable: async (
-      conflict,
-      action,
-    ): Promise<RuntimeHostNonRestartableDecision> => {
-      const locale = await resolveLocale();
-      const dialog = buildRuntimeHostUpgradeDialog(conflict, action, locale);
-      const { response } = await showDialog(
-        dialog.options,
-        locale,
-      );
-      const decision = dialog.decisions[response] ?? 'cancel';
-      return decision === 'replace' || decision === 'wait' ? decision : 'cancel';
-    },
-  };
-}
diff --git a/apps/desktop/src/main/startup-presentation.ts b/apps/desktop/src/main/startup-presentation.ts
index 20dbb17920..9f5a5376db 100644
--- a/apps/desktop/src/main/startup-presentation.ts
+++ b/apps/desktop/src/main/startup-presentation.ts
@@ -17,8 +17,9 @@
  * under the License.
  */
 
-import { app, BrowserWindow, nativeTheme } from 'electron';
-import { resolveSystemUiLocale } from '@maka/core/ui-locale';
+import { app, BrowserWindow, clipboard, nativeTheme } from 'electron';
+import { resolveSystemUiLocale, type UiLocale } from '@maka/core/ui-locale';
+import type { HostHandoffView, OpenHostHandoffSurface } from '@maka/runtime-host/client';
 import { readableAppIconPath } from './app-icon-surface.js';
 import { installApplicationMenu } from './application-menu.js';
 import { installDesktopStartupBranding } from './desktop-shell-presentation.js';
@@ -31,6 +32,7 @@ import {
 } from './startup-progress-window.js';
 
 let progress: StartupProgressWindow | undefined;
+let handoffUsesStartup = false;
 
 const focus = () => progress?.focus();
 
@@ -55,7 +57,8 @@ export function showDesktopStartupProgress(
       dark: nativeTheme.shouldUseDarkColors,
       icon: readableAppIconPath('default'),
       createWindow: (options) => new BrowserWindow(options),
-      copyDiagnostics,
+      copyDiagnostics: (phase, handoff) => handoff
+        ? clipboard.writeText(JSON.stringify(handoff, null, 2)) : copyDiagnostics(phase),
       onError: (error) => console.error('[startup] progress presentation failed:', error),
     });
     app.on('activate', focus);
@@ -71,6 +74,52 @@ export function updateDesktopStartupProgress(phase: StartupPhase): void {
   progress?.update(phase);
 }
 
+/** One presentation lifetime per attempt; startup reuses its already visible window. */
+export function createDesktopHostHandoffSurface(resolveLocale: () => Promise<UiLocale>): OpenHostHandoffSurface {
+  return (submit) => {
+    let latest: HostHandoffView | undefined;
+    let window: StartupProgressWindow | undefined;
+    let locale: UiLocale | undefined;
+    let ownWindow = false;
+    let closed = false;
+    void resolveLocale().then((resolved) => {
+      if (closed) return;
+      locale = resolved;
+      if (progress?.window() && !handoffUsesStartup) {
+        window = progress;
+        handoffUsesStartup = true;
+      } else {
+        ownWindow = true;
+        window = createStartupProgressWindow({
+          locale, dark: nativeTheme.shouldUseDarkColors, icon: readableAppIconPath('default'),
+          createWindow: (options) => new BrowserWindow(options),
+          copyDiagnostics: () => clipboard.writeText(JSON.stringify(latest, null, 2)),
+          onError: (error) => console.error('[runtime-host] handoff presentation failed:', error),
+        });
+      }
+      if (latest) window.handoff(latest, submit, locale);
+      window.focus();
+    }).catch((error) => {
+      console.error('[runtime-host] handoff presentation failed:', error);
+      if (latest) submit(latest.revision, 'cancel');
+    });
+    return {
+      update(view) {
+        latest = view;
+        if (window && locale) window.handoff(view, submit, locale);
+      },
+      close() {
+        closed = true;
+        if (ownWindow) window?.close();
+        else if (window) {
+          window.clearHandoff();
+          handoffUsesStartup = false;
+        }
+      },
+    };
+  };
+}
+
 export function desktopStartupProgressWindow(): BrowserWindow | undefined {
   return progress?.window();
 }
diff --git a/apps/desktop/src/main/startup-progress-window.ts b/apps/desktop/src/main/startup-progress-window.ts
index 88efd713cd..2f6712c4a1 100644
--- a/apps/desktop/src/main/startup-progress-window.ts
+++ b/apps/desktop/src/main/startup-progress-window.ts
@@ -20,6 +20,7 @@
 import { randomUUID } from 'node:crypto';
 import { MAKA_WORDMARK_PATH } from '@maka/core/maka-wordmark';
 import type { UiLocale } from '@maka/core/ui-locale';
+import { formatHostHandoff, type HostHandoffView, type HostHandoffAction } from '@maka/runtime-host/client';
 import type { BrowserWindow, BrowserWindowConstructorOptions } from 'electron';
 
 export type StartupPhase =
@@ -70,6 +71,8 @@ const COPY = {
 
 export interface StartupProgressWindow {
   update(phase: StartupPhase): void;
+  handoff(view: HostHandoffView, submit: (revision: string, action: HostHandoffAction) => void, locale: UiLocale): void;
+  clearHandoff(): void;
   focus(): void;
   close(): void;
   window(): BrowserWindow | undefined;
@@ -81,7 +84,7 @@ export function createStartupProgressWindow(input: {
   dark: boolean;
   icon: string;
   createWindow(options: BrowserWindowConstructorOptions): BrowserWindow;
-  copyDiagnostics(phase: StartupPhase): void | Promise<void>;
+  copyDiagnostics(phase: StartupPhase, handoff?: HostHandoffView): void | Promise<void>;
   onError(error: unknown): void;
 }): StartupProgressWindow {
   const copy = COPY[input.locale];
@@ -97,15 +100,22 @@ export function createStartupProgressWindow(input: {
   let closed = false;
   let loaded = false;
   let phase: StartupPhase = 'prepare';
+  let handoff: { view: HostHandoffView; submit(revision: string, action: HostHandoffAction): void; locale: UiLocale } | undefined;
   const execute = (source: string) => {
     if (!closed && loaded && !win.isDestroyed()) {
       void win.webContents.executeJavaScript(source).catch(input.onError);
     }
   };
-  const publish = () => execute(
-    'document.getElementById("phase").textContent = ' + JSON.stringify(copy.phases[phase]) +
-    '; document.body.dataset.phase = ' + JSON.stringify(phase) + ';',
-  );
+  const publish = () => {
+    if (handoff) {
+      const presentation = formatHostHandoff(handoff.view, handoff.locale);
+      execute('window.renderHandoff(' + JSON.stringify({ ...presentation, revision: handoff.view.revision,
+        state: handoff.view.state, diagnostic: handoff.view.diagnostic }) + ');');
+    } else execute(
+      'window.renderHandoff(null); document.getElementById("phase").textContent = ' + JSON.stringify(copy.phases[phase]) +
+      '; document.body.dataset.phase = ' + JSON.stringify(phase) + ';',
+    );
+  };
   const close = () => {
     if (closed) return;
     closed = true;
@@ -121,8 +131,15 @@ export function createStartupProgressWindow(input: {
   });
   win.webContents.on('will-navigate', (event, url) => {
     event.preventDefault();
+    if (url.startsWith('maka-startup://handoff/')) {
+      const match = /^maka-startup:\/\/handoff\/([a-z0-9-]+)\/(cancel|retry|interrupt)$/.exec(url);
+      if (match && handoff?.view.revision === match[1] && handoff.view.actions.includes(match[2] as HostHandoffAction)) {
+        handoff.submit(match[1], match[2] as HostHandoffAction);
+      }
+      return;
+    }
     if (url !== 'maka-startup://copy') return;
-    void Promise.resolve().then(() => input.copyDiagnostics(phase)).then(
+    void Promise.resolve().then(() => input.copyDiagnostics(phase, handoff?.view)).then(
       () => execute('document.getElementById("copy").textContent = ' + JSON.stringify(copy.copied)),
       (error) => {
         input.onError(error);
@@ -133,6 +150,7 @@ export function createStartupProgressWindow(input: {
   win.webContents.on('will-redirect', (event) => event.preventDefault());
   win.webContents.on('render-process-gone', (_event, details) => {
     input.onError(new Error('Startup renderer exited: ' + details.reason));
+    handoff?.submit(handoff.view.revision, 'cancel');
     close();
   });
   // No await: failure to present progress must never block Host recovery.
@@ -142,14 +160,32 @@ export function createStartupProgressWindow(input: {
     if (closed || win.isDestroyed()) return;
     loaded = true;
     publish();
-    // A confirmation may already be open; never raise progress above it.
-    win.showInactive();
+    if (handoff?.view.state === 'attention') { win.show(); win.focus(); }
+    else win.showInactive();
   }).catch((error) => {
     input.onError(error);
+    handoff?.submit(handoff.view.revision, 'cancel');
     close();
   });
   return {
     update(next) { phase = next; publish(); },
+    handoff(view, submit, locale) {
+      if (closed || win.isDestroyed()) { submit(view.revision, 'cancel'); return; }
+      const first = handoff === undefined;
+      const needsAttention = handoff?.view.state !== 'attention' && view.state === 'attention';
+      handoff = { view, submit, locale };
+      if (first && !closed && !win.isDestroyed()) win.setSize(560, 540);
+      publish();
+      if (loaded && needsAttention) {
+        if (win.isMinimized()) win.restore();
+        win.show(); win.focus();
+      }
+    },
+    clearHandoff() {
+      handoff = undefined;
+      if (!closed && !win.isDestroyed()) win.setSize(520, 390);
+      publish();
+    },
     focus() {
       if (closed || !loaded || win.isDestroyed()) return;
       if (win.isMinimized()) win.restore();
@@ -180,15 +216,47 @@ footer { display: flex; justify-content: space-between; align-items: center; mar
 #elapsed { opacity: .55; font-variant-numeric: tabular-nums; }
 button { font: inherit; color: inherit; background: transparent; border: 1px solid ${dark ? '#48494f' : '#dedee3'}; border-radius: 7px; padding: 6px 10px; cursor: pointer; }
 button:hover { background: ${dark ? '#303137' : '#f4f4f6'}; } button:focus-visible { outline: 2px solid #788aff; outline-offset: 3px; }
+#handoff-detail { white-space: pre-line; margin-top: 18px; } #actions { display: flex; flex-wrap: wrap; gap: 10px; margin-top: 24px; }
+#actions .destructive { border-color: ${dark ? '#c77976' : '#bc443d'}; color: ${dark ? '#ffada7' : '#a42c25'}; }
+#handoff-diagnostic { white-space: pre-wrap; overflow-wrap: anywhere; max-height: 70px; overflow: auto; font: 11px/1.4 monospace; opacity: .6; }
+body[data-handoff] #slow, body[data-handoff] .status { display: none; }
 @keyframes spin { to { transform: rotate(360deg); } } @media (prefers-reduced-motion: reduce) { .spinner { animation: none; } }
 </style></head><body>
 <svg viewBox="0 0 460 120" role="img" aria-label="Maka"><g transform="translate(0,120) scale(0.1,-0.1)"><path d="${MAKA_WORDMARK_PATH}"/></g></svg>
-<h1>${copy.title}</h1><p>${copy.detail}</p>
+<h1 id="title">${copy.title}</h1><p id="description">${copy.detail}</p>
+<p id="handoff-detail" hidden></p><pre id="handoff-diagnostic" hidden></pre><div id="actions" hidden></div>
 <div class="status" role="status" aria-live="polite"><span class="spinner" aria-hidden="true"></span><span id="phase">${copy.phases.prepare}</span></div>
 <p id="slow">${copy.slow}</p>
 <footer><span id="elapsed"></span><button id="copy">${copy.copy}</button></footer>
 <script nonce="${nonce}">
 const started = performance.now();
+let revision;
+window.renderHandoff = (view) => {
+  const changed = revision !== view?.revision;
+  revision = view?.revision;
+  if (view) document.body.dataset.handoff = view.state;
+  else delete document.body.dataset.handoff;
+  document.getElementById('title').textContent = view?.title ?? ${JSON.stringify(copy.title)};
+  document.getElementById('description').textContent = view?.description ?? ${JSON.stringify(copy.detail)};
+  const detail = document.getElementById('handoff-detail');
+  detail.hidden = !view;
+  detail.textContent = view?.detail ?? '';
+  const diagnostic = document.getElementById('handoff-diagnostic');
+  diagnostic.hidden = !view?.diagnostic;
+  diagnostic.textContent = view?.diagnostic ?? '';
+  const actions = document.getElementById('actions');
+  actions.hidden = !view;
+  if (!changed) return;
+  actions.replaceChildren();
+  for (const item of view?.actions ?? []) {
+    const button = document.createElement('button');
+    button.textContent = item.label;
+    if (item.action === 'interrupt') button.className = 'destructive';
+    button.addEventListener('click', () => { location.href = 'maka-startup://handoff/' + view.revision + '/' + item.action; });
+    actions.append(button);
+    if (item.action === 'cancel') button.focus();
+  }
+};
 setInterval(() => {
   const seconds = Math.floor((performance.now() - started) / 1000);
   document.getElementById('elapsed').textContent = ${JSON.stringify(copy.elapsed)} + ' ' + Math.floor(seconds / 60) + ':' + String(seconds % 60).padStart(2, '0');
diff --git a/packages/cli/src/__tests__/runtime-host-cli-context.test.ts b/packages/cli/src/__tests__/runtime-host-cli-context.test.ts
index 8d39fbf148..a366daded2 100644
--- a/packages/cli/src/__tests__/runtime-host-cli-context.test.ts
+++ b/packages/cli/src/__tests__/runtime-host-cli-context.test.ts
@@ -28,6 +28,7 @@ import {
   createClientRuntimeHostProfileCatalog,
   RuntimeHostRemoteCompatibilityError,
   RuntimeHostStartupError,
+  HostHandoffRequiredError,
   type RuntimeHostConnection,
   type RuntimeHostProfileCatalog,
   type RemoteRuntimeHostProfile,
@@ -43,9 +44,6 @@ import {
 import {
   connectRuntimeHostCli,
   connectRuntimeHostCliConnection,
-  resolveRuntimeHostCliConflictDecision,
-  RuntimeHostCliConflictError,
-  shouldRetryRuntimeHostConflict,
 } from '../runtime-host-cli-context.js';
 
 const V0_1_11_HOST_COMPATIBILITY_EPOCH = 25;
@@ -238,6 +236,10 @@ test('non-interactive CLI reports how to retire an incompatible Runtime Host', a
     connectRuntimeHostCli(
       { rootPath: '/runtime-host-root' },
       {
+        readDeploymentRecord: async () => undefined,
+        resolveInstallation: async () => {
+          throw new Error('Not installed globally');
+        },
         connectOrSpawn: async () => ({
           kind: 'incompatible',
           registration: hostRegistration({
@@ -258,19 +260,11 @@ test('non-interactive CLI reports how to retire an incompatible Runtime Host', a
       },
     ),
     (error: unknown) => {
-      assert.ok(error instanceof RuntimeHostCliConflictError);
-      assert.equal(error.code, 'RUNTIME_HOST_RESTART_REQUIRED');
-      assert.match(
-        error.message,
-        new RegExp(
-          `PID 42; lifecycle ephemeral; compatibility epoch ${V0_1_11_HOST_COMPATIBILITY_EPOCH}`,
-        ),
-      );
-      assert.match(
-        error.message,
-        /ephemeral Host is not currently idle and cannot be replaced by this Client/,
-      );
-      assert.match(error.message, /previous compatible Maka build/);
+      assert.ok(error instanceof HostHandoffRequiredError);
+      assert.equal(error.view.reason, 'operator_required');
+      assert.equal(error.view.activity, undefined);
+      assert.deepEqual(error.view.actions, ['cancel', 'retry']);
+      assert.match(error.message, /operator/);
       return true;
     },
   );
@@ -281,6 +275,7 @@ test('CLI explains a service Host without inventing resident work', async () =>
     connectRuntimeHostCli(
       { rootPath: '/runtime-host-root' },
       {
+        readDeploymentRecord: async () => undefined,
         connectOrSpawn: async () => ({
           kind: 'incompatible',
           registration: hostRegistration({ lifecycleMode: 'service' }),
@@ -299,31 +294,16 @@ test('CLI explains a service Host without inventing resident work', async () =>
       },
     ),
     (error: unknown) => {
-      assert.ok(error instanceof RuntimeHostCliConflictError);
-      assert.match(error.message, /service Host is managed by its operator/);
-      assert.match(error.message, /service operator to inspect or upgrade/);
+      assert.ok(error instanceof HostHandoffRequiredError);
+      assert.equal(error.view.reason, 'operator_required');
+      assert.equal(error.view.mayExitNaturally, false);
+      assert.match(error.message, /operator/);
       assert.doesNotMatch(error.message, /not idle/);
       return true;
     },
   );
 });
 
-test('Runtime Host conflict waits only after an explicit wait answer', () => {
-  assert.equal(shouldRetryRuntimeHostConflict('w'), true);
-  assert.equal(shouldRetryRuntimeHostConflict(' wait '), true);
-  assert.equal(shouldRetryRuntimeHostConflict(' W '), true);
-  assert.equal(shouldRetryRuntimeHostConflict('WAIT'), true);
-  assert.equal(shouldRetryRuntimeHostConflict(''), false);
-  assert.equal(shouldRetryRuntimeHostConflict('c'), false);
-  assert.equal(shouldRetryRuntimeHostConflict('cancel'), false);
-  assert.equal(shouldRetryRuntimeHostConflict('unexpected'), false);
-  assert.equal(resolveRuntimeHostCliConflictDecision('r', true), 'restart');
-  assert.equal(resolveRuntimeHostCliConflictDecision(' restart ', true), 'restart');
-  assert.equal(resolveRuntimeHostCliConflictDecision('r', false), 'cancel');
-  assert.equal(resolveRuntimeHostCliConflictDecision('w', true), 'wait');
-  assert.equal(resolveRuntimeHostCliConflictDecision('', true), 'cancel');
-});
-
 test('CLI reports an actionable stored-data startup failure', async () => {
   await assert.rejects(
     connectRuntimeHostCli(
@@ -604,28 +584,14 @@ test('remote profiles preserve shared compatibility errors', async () => {
           },
         ),
       (error: unknown) => {
-        assert.ok(error instanceof RuntimeHostRemoteCompatibilityError);
-        assert.equal(error.code, 'RUNTIME_HOST_REMOTE_INCOMPATIBLE');
+        assert.ok(error instanceof HostHandoffRequiredError);
+        assert.deepEqual(error.view.actions, ['cancel', 'retry']);
+        assert.equal(error.view.target.hostEpoch, handshake.hostEpoch);
         assert.equal(
-          error.message,
+          error.view.diagnostic,
           new RuntimeHostRemoteCompatibilityError(profile.id, handshake).message,
         );
-        assert.deepEqual(error.details, {
-          profileId: profile.id,
-          client: {
-            compatibilityEpoch: RUNTIME_HOST_COMPATIBILITY_EPOCH,
-            protocolMin: RUNTIME_HOST_PROTOCOL_VERSION,
-            protocolMax: RUNTIME_HOST_PROTOCOL_VERSION,
-            compositionId: INTERACTIVE_RUNTIME_HOST_COMPOSITION_ID,
-          },
-          host: {
-            compatibilityEpoch: handshake.compatibilityEpoch,
-            protocolMin: handshake.protocolMin,
-            protocolMax: handshake.protocolMax,
-            compositionId: handshake.compositionId,
-            compositionRevision: handshake.compositionRevision,
-          },
-        });
+        assert.equal(error.view.target.rootId, profile.rootId);
         return true;
       },
     );
diff --git a/packages/cli/src/__tests__/runtime-host-lifecycle-transaction.test.ts b/packages/cli/src/__tests__/runtime-host-lifecycle-transaction.test.ts
index 2030626f6c..f7ed2ed165 100644
--- a/packages/cli/src/__tests__/runtime-host-lifecycle-transaction.test.ts
+++ b/packages/cli/src/__tests__/runtime-host-lifecycle-transaction.test.ts
@@ -21,9 +21,11 @@ import assert from 'node:assert/strict';
 import { mkdtemp, rm, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
+import { PassThrough } from 'node:stream';
 import test from 'node:test';
 import {
   beginRuntimeHostManagedDeploymentTransition,
+  RUNTIME_HOST_OPERATOR_RETIREMENT_CANCELLATION_ENV,
   claimRuntimeHostManagedDeployment,
   readRuntimeHostManagedDeploymentAuthorityRecord,
   resolveRuntimeHostManagedDeploymentConfigPath,
@@ -57,6 +59,68 @@ import {
 const INTEGRITY = `sha512-${Buffer.alloc(64, 7).toString('base64')}`;
 const UPDATED_INTEGRITY = `sha512-${Buffer.alloc(64, 8).toString('base64')}`;
 
+test('operator cancellation covers non-RPC retirement and cannot leak into recovery', async (t) => {
+  const originalEnv = process.env[RUNTIME_HOST_OPERATOR_RETIREMENT_CANCELLATION_ENV];
+  t.after(() => {
+    if (originalEnv === undefined)
+      delete process.env[RUNTIME_HOST_OPERATOR_RETIREMENT_CANCELLATION_ENV];
+    else process.env[RUNTIME_HOST_OPERATOR_RETIREMENT_CANCELLATION_ENV] = originalEnv;
+  });
+  for (const busy of [false, true]) {
+    const stateRoot = await mkdtemp(join(tmpdir(), 'maka-retirement-cancel-'));
+    t.after(() => rm(stateRoot, { recursive: true, force: true }));
+    const capability = await resolveStorageRoot({ path: stateRoot, kind: 'interactive' });
+    let owner = busy ? await tryAcquireStateRootOwner(capability) : null;
+    t.after(async () => {
+      await owner?.close();
+    });
+    const input = new PassThrough();
+    const stdinMock = t.mock.getter(
+      process,
+      'stdin',
+      () => input as unknown as typeof process.stdin,
+    );
+    process.env[RUNTIME_HOST_OPERATOR_RETIREMENT_CANCELLATION_ENV] = '1';
+    let cancelled = false;
+    let retired = false;
+    const request = {
+      rootPath: capability.canonicalPath,
+      rootId: capability.rootId,
+      expectedOwner: { hostEpoch: 'host-a', pid: 42 },
+      allowInterruptActiveTasks: true,
+      connectExisting: (async () => ({
+        kind: 'incompatible',
+        registration: { hostEpoch: 'host-a', pid: 42 },
+      })) as unknown as typeof connectExistingRuntimeHost,
+      supervisor: {
+        status: async () => {
+          assert.equal(process.env[RUNTIME_HOST_OPERATOR_RETIREMENT_CANCELLATION_ENV], undefined);
+          if (!cancelled) {
+            cancelled = true;
+            input.end();
+            await new Promise<void>((resolve) => setImmediate(resolve));
+          }
+          return { active: true, pid: 42 };
+        },
+        retire: async () => {
+          retired = true;
+          await owner?.close();
+          owner = null;
+        },
+      },
+    };
+    await assert.rejects(retireRuntimeHostLifecycleOwner(request), /retirement was cancelled/u);
+    assert.equal(retired, false);
+    // The original channel is now consumed. Recovery is allowed to complete
+    // even though its parent's pipe remains at EOF.
+    const recovery = await retireRuntimeHostLifecycleOwner(request);
+    assert.equal(recovery.kind, 'retired');
+    if (recovery.kind === 'retired') await recovery.owner.close();
+    assert.equal(retired, true);
+    stdinMock.mock.restore();
+  }
+});
+
 test('control projection repair leaves the running Host supervisor untouched', async () => {
   const current = config('/workspace', 'a'.repeat(64), 1, 'launch_agent');
   const calls: string[] = [];
diff --git a/packages/cli/src/__tests__/runtime-host-local-handoff.test.ts b/packages/cli/src/__tests__/runtime-host-local-handoff.test.ts
index d1d3eaf0c6..8002fb1dd6 100644
--- a/packages/cli/src/__tests__/runtime-host-local-handoff.test.ts
+++ b/packages/cli/src/__tests__/runtime-host-local-handoff.test.ts
@@ -306,6 +306,34 @@ test('installed release skew is rejected before staging or authority mutation',
   assert.deepEqual(await readLocalHostDeploymentRecord(ROOT_ID, { authorityRoot }), claimed.record);
 });
 
+test('a changed npm installation invalidates handoff consent before staging or authority mutation', async () => {
+  const installation = {
+    owner: CLI_OWNER,
+    observedRelease: {
+      version: TARGET.version,
+      packageRoot: '/installation',
+      cliPath: '/installation/dist/cli.js',
+    },
+  };
+  const result = await restartRuntimeHostNpmGlobalDeployment(
+    {
+      rootPath: '/root-under-test',
+      registration: hostRegistration(),
+      expectedInstallation: installation,
+    },
+    {},
+    {
+      resolveInstallation: async () => ({
+        ...installation,
+        observedRelease: { ...installation.observedRelease, version: '9.0.0' },
+      }),
+      readRecord: async () => assert.fail('changed installation cannot enter deployment authority'),
+      resolveCandidate: async () => assert.fail('changed installation cannot stage a target'),
+    },
+  );
+  assert.deepEqual(result, { kind: 'changed' });
+});
+
 test('explicit npm-global restart claims an exact staged legacy takeover', async (t) => {
   const base = await mkdtemp(join(tmpdir(), 'maka-local-restart-'));
   t.after(() => rm(base, { recursive: true, force: true }));
diff --git a/packages/cli/src/__tests__/runtime-host-operator-retirement.test.ts b/packages/cli/src/__tests__/runtime-host-operator-retirement.test.ts
new file mode 100644
index 0000000000..35d57b6e28
--- /dev/null
+++ b/packages/cli/src/__tests__/runtime-host-operator-retirement.test.ts
@@ -0,0 +1,47 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import assert from 'node:assert/strict';
+import { PassThrough } from 'node:stream';
+import test from 'node:test';
+import { withRetirementCancellation } from '../runtime-host-operator-retirement.js';
+
+test('operator stdin EOF cancels reversible retirement, not a committed result or later recovery', async () => {
+  const input = new PassThrough();
+  const result = withRetirementCancellation(input, async (signal) => {
+    await new Promise<void>((resolve) =>
+      signal.addEventListener('abort', () => resolve(), { once: true }),
+    );
+    signal.throwIfAborted();
+  });
+  input.end();
+  await assert.rejects(result, /retirement was cancelled/u);
+  assert.equal(input.listenerCount('end'), 0);
+
+  const committedInput = new PassThrough();
+  const committed = withRetirementCancellation(committedInput, async (signal) => {
+    committedInput.end();
+    await new Promise<void>((resolve) =>
+      signal.addEventListener('abort', () => resolve(), { once: true }),
+    );
+    return 'committed';
+  });
+  assert.equal(await committed, 'committed');
+  assert.equal(committedInput.listenerCount('end'), 0);
+});
diff --git a/packages/cli/src/cli-core.ts b/packages/cli/src/cli-core.ts
index b7cceffd30..47ece5ea45 100644
--- a/packages/cli/src/cli-core.ts
+++ b/packages/cli/src/cli-core.ts
@@ -496,6 +496,7 @@ export async function runMakaCli(
         ...(command.expectedConfigFingerprint
           ? { expectedConfigFingerprint: command.expectedConfigFingerprint }
           : {}),
+        ...(command.expectedHost ? { expectedHost: command.expectedHost } : {}),
         ...(command.retainManagedDeployment ? { retainManagedDeployment: true } : {}),
         ...(command.allowInterruptActiveTasks ? { allowInterruptActiveTasks: true } : {}),
       });
diff --git a/packages/cli/src/runtime-host-cli-context.ts b/packages/cli/src/runtime-host-cli-context.ts
index b148320530..a1c94f8172 100644
--- a/packages/cli/src/runtime-host-cli-context.ts
+++ b/packages/cli/src/runtime-host-cli-context.ts
@@ -35,6 +35,11 @@ import {
   LOCAL_RUNTIME_HOST_PROFILE,
   readRuntimeHostConnectionCatalog,
   RuntimeHostPermanentReconnectError,
+  RuntimeHostRemoteCompatibilityError,
+  runHostHandoff,
+  type OpenHostHandoffSurface,
+  type HostHandoffReplacement,
+  type HostHandoffObservation,
   runtimeHostStartupError,
   type RuntimeHostConnection,
   type RuntimeHostProfile,
@@ -44,13 +49,15 @@ import {
 } from '@maka/runtime-host/client';
 import {
   INTERACTIVE_RUNTIME_HOST_COMPOSITION_ID,
-  RUNTIME_HOST_COMPATIBILITY_EPOCH,
   RUNTIME_HOST_PROTOCOL_VERSION,
-  type HostRegistration,
-  type HostIncompatible,
 } from '@maka/runtime-host/protocol';
 import { readLocalHostDeploymentRecord } from '@maka/runtime-host/operator';
 import { resolveMakaClientDataRoot } from '@maka/storage/workspace-root';
+import { resolveRuntimeHostNpmGlobalInstallation } from './runtime-host-cli-installation.js';
+import {
+  restartRuntimeHostNpmGlobalDeployment,
+  runtimeHostNpmGlobalSourceRetirementAvailable,
+} from './runtime-host-local-handoff.js';
 
 /**
  * The mode a new Session starts in belongs to the Host: `session.create`
@@ -74,18 +81,6 @@ export async function readHostChatDefaultPermissionMode(
   return (await connection.request('runtime.policy.query', {})).policy.chatDefaults.permissionMode;
 }
 
-export class RuntimeHostCliConflictError extends RuntimeHostPermanentReconnectError {
-  readonly code = 'RUNTIME_HOST_RESTART_REQUIRED';
-
-  constructor(
-    readonly handshake: HostIncompatible,
-    readonly registration: HostRegistration,
-  ) {
-    super(formatRuntimeHostCliConflict(handshake, registration));
-    this.name = 'RuntimeHostCliConflictError';
-  }
-}
-
 export interface RuntimeHostCliConnectionOnlyContext {
   readonly connection: RuntimeHostConnection;
   readonly profile: RuntimeHostProfile;
@@ -112,6 +107,7 @@ export interface RuntimeHostCliConnectionInput {
   readonly clientDataRoot?: string;
   readonly interactiveSsh?: boolean;
   readonly signal?: AbortSignal;
+  readonly handoffSurface?: OpenHostHandoffSurface;
 }
 
 export interface RuntimeHostCliTarget {
@@ -128,6 +124,9 @@ interface RuntimeHostCliContextDeps {
   readonly readDeploymentRecord: typeof readLocalHostDeploymentRecord;
   readonly createPeerClient: typeof createRuntimeHostPeerClientFromEnvironment;
   readonly profileCatalog?: RuntimeHostProfileCatalog;
+  readonly resolveInstallation: typeof resolveRuntimeHostNpmGlobalInstallation;
+  readonly restartDeployment: typeof restartRuntimeHostNpmGlobalDeployment;
+  readonly sourceRetirementAvailable: typeof runtimeHostNpmGlobalSourceRetirementAvailable;
 }
 
 export async function connectRuntimeHostCli(
@@ -162,6 +161,9 @@ export async function connectRuntimeHostCliConnection(
     ),
     readDeploymentRecord: readLocalHostDeploymentRecord,
     createPeerClient: createRuntimeHostPeerClientFromEnvironment,
+    resolveInstallation: resolveRuntimeHostNpmGlobalInstallation,
+    restartDeployment: restartRuntimeHostNpmGlobalDeployment,
+    sourceRetirementAvailable: runtimeHostNpmGlobalSourceRetirementAvailable,
     ...overrides,
   };
   const resolvedProfile = await resolveHostProfile(input, deps);
@@ -187,41 +189,130 @@ export async function connectRuntimeHostCliConnection(
     signal?: AbortSignal,
     sshInteraction: 'batch' | 'inherit' = 'batch',
   ): Promise<RuntimeHostConnection> => {
-    if (profile.kind !== 'local') {
-      return deps.connectProfile({
-        profile,
-        ...(resolvedProfile.credential ? { credential: resolvedProfile.credential } : {}),
-        clientInstanceId,
-        sshInteraction,
-        ...(peerClient ? { peerClient } : {}),
+    const observe = async (): Promise<HostHandoffObservation<RuntimeHostConnection>> => {
+      if (profile.kind !== 'local') {
+        try {
+          const connection = await deps.connectProfile({
+            profile,
+            ...(resolvedProfile.credential ? { credential: resolvedProfile.credential } : {}),
+            clientInstanceId,
+            sshInteraction,
+            ...(peerClient ? { peerClient } : {}),
+            ...(signal ? { signal } : {}),
+          });
+          return { kind: 'ready', value: connection };
+        } catch (error) {
+          if (!(error instanceof RuntimeHostRemoteCompatibilityError)) throw error;
+          return {
+            kind: 'blocked',
+            blocker: {
+              identity: JSON.stringify([profile, error.hostEpoch, error.details]),
+              target: {
+                name: profile.name,
+                location: 'remote',
+                rootId: profile.rootId,
+                hostEpoch: error.hostEpoch,
+              },
+              reason: 'upgrade',
+              mayExitNaturally: false,
+              diagnostic: error.message,
+            },
+          };
+        }
+      }
+      const connected = await deps.connectOrSpawn({
+        ...connectInput,
         ...(signal ? { signal } : {}),
       });
-    }
-    const connected = await deps.connectOrSpawn({
-      ...connectInput,
-      ...(signal ? { signal } : {}),
-    });
-    if (connected.kind === 'incompatible') {
-      throw new RuntimeHostCliConflictError(connected.handshake, connected.registration);
-    }
-    if (connected.kind === 'upgrade_required') {
-      throw new RuntimeHostPermanentReconnectError(
-        'RUNTIME_HOST_RESTART_REQUIRED: An older Runtime Host build is still running. Restart it, or wait for its background work to finish.',
-      );
-    }
-    if (connected.kind === 'failed') {
-      throw runtimeHostStartupError(connected.reason, connected.diagnostic);
-    }
-    if (connected.registration.generation?.startsWith('npm-global-handoff:')) {
-      const record = await deps.readDeploymentRecord(connected.registration.rootId);
-      if (record?.state.kind !== 'owned' || record.state.owner.kind !== 'cli') {
-        await connected.connection.close().catch(() => undefined);
-        throw new RuntimeHostPermanentReconnectError(
-          'RUNTIME_HOST_RECOVERY_REQUIRED: The staged local Runtime Host is Ready, but its installation ownership was not durably committed.',
-        );
+      if (connected.kind === 'incompatible' || connected.kind === 'upgrade_required') {
+        const record = await deps.readDeploymentRecord(connected.registration.rootId);
+        let replacement: HostHandoffReplacement | undefined;
+        let installation;
+        if (connected.registration.lifecycleMode === 'ephemeral') {
+          try {
+            installation = await deps.resolveInstallation();
+          } catch {
+            /* No persistent installation authority. */
+          }
+          const owner = record?.state.kind === 'handoff' ? record.state.from : record?.state.owner;
+          if (
+            installation &&
+            (!owner ||
+              (owner.kind === installation.owner.kind &&
+                owner.installationId === installation.owner.installationId))
+          ) {
+            const expectedInstallation = installation;
+            const canInterrupt = record
+              ? await deps
+                  .sourceRetirementAvailable({
+                    rootId: connected.registration.rootId,
+                    owner: installation.owner,
+                    source: record.state.selected,
+                  })
+                  .catch(() => false)
+              : false;
+            replacement = {
+              kind: record?.state.kind === 'handoff' ? 'repair' : 'replace',
+              canReplaceIdle: true,
+              canInterrupt,
+              execute: async (activeWorkPolicy, _progress, _consent, attemptSignal) => {
+                const result = await deps.restartDeployment({
+                  rootPath: input.rootPath,
+                  registration: connected.registration,
+                  activeWorkPolicy,
+                  expectedInstallation,
+                  ...(attemptSignal ? { signal: attemptSignal } : {}),
+                });
+                if (result.kind === 'completed') return { kind: 'completed' };
+                if (result.kind === 'active_work') return { kind: 'active_work' };
+                if (
+                  result.kind === 'changed' ||
+                  result.kind === 'rejected' ||
+                  result.kind === 'operator_required'
+                )
+                  return { kind: 'changed' };
+                return {
+                  kind: 'recovery_required',
+                  diagnostic: `Local service recovery is required at ${result.phase}`,
+                };
+              },
+            };
+          }
+        }
+        return {
+          kind: 'blocked',
+          blocker: {
+            identity: JSON.stringify([connected.registration, record, installation]),
+            target: {
+              name: profile.name,
+              location: 'local',
+              rootId: connected.registration.rootId,
+              hostEpoch: connected.registration.hostEpoch,
+            },
+            reason: record?.state.kind === 'handoff' ? 'repair' : 'upgrade',
+            ...(connected.handshake?.activity ? { activity: connected.handshake.activity } : {}),
+            mayExitNaturally:
+              connected.registration.lifecycleMode === 'ephemeral' &&
+              connected.handshake?.replacement === 'wait_for_idle_exit',
+            ...(replacement ? { replacement } : {}),
+          },
+        };
       }
-    }
-    return connected.connection;
+      if (connected.kind === 'failed') {
+        throw runtimeHostStartupError(connected.reason, connected.diagnostic);
+      }
+      if (connected.registration.generation?.startsWith('npm-global-handoff:')) {
+        const record = await deps.readDeploymentRecord(connected.registration.rootId);
+        if (record?.state.kind !== 'owned' || record.state.owner.kind !== 'cli') {
+          await connected.connection.close().catch(() => undefined);
+          throw new RuntimeHostPermanentReconnectError(
+            'RUNTIME_HOST_RECOVERY_REQUIRED: The staged local Runtime Host is Ready, but its installation ownership was not durably committed.',
+          );
+        }
+      }
+      return { kind: 'ready', value: connected.connection };
+    };
+    return runHostHandoff({ observe, signal, openSurface: input.handoffSurface });
   };
   let initialConnection: RuntimeHostConnection | undefined;
   let connection: Awaited<ReturnType<typeof createRuntimeHostReconnectingConnection>> | undefined;
@@ -334,54 +425,6 @@ async function resolveHostProfile(
   return catalog.resolve(input.profileId);
 }
 
-function formatRuntimeHostCliConflict(
-  handshake: HostIncompatible,
-  registration: HostRegistration,
-): string {
-  const lines = [
-    'RUNTIME_HOST_RESTART_REQUIRED: An older Runtime Host is still running and cannot accept this client.',
-    `Local Runtime Host: PID ${registration.pid}; lifecycle ${registration.lifecycleMode ?? 'unknown'}; compatibility epoch ${registration.compatibilityEpoch}.`,
-  ];
-  if (registration.lifecycleMode === 'ephemeral') {
-    lines.push('The ephemeral Host is not currently idle and cannot be replaced by this Client.');
-  } else if (registration.lifecycleMode === 'service') {
-    lines.push(
-      'This service Host is managed by its operator and cannot be replaced by this Client.',
-    );
-  } else {
-    lines.push('This Host cannot be replaced by this Client.');
-  }
-  if (handshake.compatibilityEpoch < RUNTIME_HOST_COMPATIBILITY_EPOCH) {
-    lines.push(
-      registration.lifecycleMode === 'service'
-        ? 'Use the service operator to inspect or upgrade the Host.'
-        : 'Use a previous compatible Maka build to inspect the Host and finish or clear any retained work. Stop the Host only after deciding that interruption is safe.',
-    );
-  } else {
-    lines.push(
-      `Host protocol ${handshake.protocolMin}-${handshake.protocolMax}; CLI protocol ${RUNTIME_HOST_PROTOCOL_VERSION}.`,
-    );
-  }
-  return lines.join('\n');
-}
-
-export function shouldRetryRuntimeHostConflict(answer: string): boolean {
-  const normalized = answer.trim().toLowerCase();
-  return normalized === 'w' || normalized === 'wait';
-}
-
-export type RuntimeHostCliConflictDecision = 'restart' | 'wait' | 'cancel';
-
-export function resolveRuntimeHostCliConflictDecision(
-  answer: string,
-  canRestart: boolean,
-): RuntimeHostCliConflictDecision {
-  const normalized = answer.trim().toLowerCase();
-  if (canRestart && (normalized === 'r' || normalized === 'restart')) return 'restart';
-  if (normalized === 'w' || normalized === 'wait') return 'wait';
-  return 'cancel';
-}
-
 export function resolveRuntimeHostCliTarget(
   catalog: ConnectionCatalogSnapshot,
   input: { readonly connectionSlug?: string; readonly model?: string } = {},
diff --git a/packages/cli/src/runtime-host-cli.ts b/packages/cli/src/runtime-host-cli.ts
index 0915703d62..1e890af8c2 100644
--- a/packages/cli/src/runtime-host-cli.ts
+++ b/packages/cli/src/runtime-host-cli.ts
@@ -173,6 +173,7 @@ export type RuntimeHostCliCommand =
       websocketPath?: string;
       expectedTarget?: RuntimeHostManagedServiceTarget;
       expectedConfigFingerprint?: string;
+      expectedHost?: RuntimeHostExpectedHost;
       retainManagedDeployment?: true;
       allowInterruptActiveTasks?: true;
     }
@@ -873,7 +874,7 @@ function parseServiceManagementCommand(argv: string[]): RuntimeHostCliCommand {
             },
           }
         : {}),
-      ...(action === 'update'
+      ...(action === 'update' || action === 'restart'
         ? {
             '--expected-host-json': (value: string) => {
               if (expectedHost !== undefined) return error('Duplicate --expected-host-json');
@@ -998,10 +999,13 @@ function parseServiceManagementCommand(argv: string[]): RuntimeHostCliCommand {
       ...(allowInterruptActiveTasks ? { allowInterruptActiveTasks: true } : {}),
     };
   }
+  if (expectedHost && !options.managedRootId)
+    return error('--expected-host-json requires --managed-root-id');
   return {
     kind: 'runtime-host-service-manage',
     action,
     ...options,
+    ...(expectedHost ? { expectedHost } : {}),
     ...(clientDataRoot ? { clientDataRoot } : {}),
     ...(options.managedRootId ? { managedRootId: options.managedRootId } : {}),
     ...(retainManagedDeployment ? { retainManagedDeployment: true } : {}),
diff --git a/packages/cli/src/runtime-host-handoff-surface.ts b/packages/cli/src/runtime-host-handoff-surface.ts
new file mode 100644
index 0000000000..4db7343a5b
--- /dev/null
+++ b/packages/cli/src/runtime-host-handoff-surface.ts
@@ -0,0 +1,94 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { createInterface } from 'node:readline';
+import { stripVTControlCharacters } from 'node:util';
+import type { Readable, Writable } from 'node:stream';
+import type { UiLocale } from '@maka/core/ui-locale';
+import {
+  formatHostHandoff,
+  type HostHandoffView,
+  type OpenHostHandoffSurface,
+} from '@maka/runtime-host/client';
+
+/** One readline lifetime renders the shared decision; it never selects replacement policy. */
+export function createCliHostHandoffSurface(
+  locale: UiLocale,
+  input: Readable = process.stdin,
+  output: Writable & { isTTY?: boolean } = process.stderr,
+): OpenHostHandoffSurface {
+  return (submit) => {
+    const readline = createInterface({ input, output, terminal: output.isTTY === true });
+    let current: HostHandoffView | undefined;
+    let closed = false;
+    let ended = false;
+    const cancel = () => {
+      if (current) submit(current.revision, 'cancel');
+    };
+    readline.on('SIGINT', cancel);
+    readline.on('close', () => {
+      ended = true;
+      if (!closed) cancel();
+    });
+    readline.on('line', (line) => {
+      if (!current) return;
+      const answer = line.trim().toLowerCase();
+      const action = answer === 'r' ? 'retry' : answer === 'stop' ? 'interrupt' : 'cancel';
+      if (!current.actions.includes(action)) {
+        readline.prompt();
+        return;
+      }
+      submit(current.revision, action);
+    });
+    return {
+      update(view) {
+        if (closed || current?.revision === view.revision) return;
+        current = view;
+        if (ended) {
+          cancel();
+          return;
+        }
+        // Discard partially typed consent when the observed target/consequences change.
+        if (output.isTTY) readline.write(null, { ctrl: true, name: 'u' });
+        const copy = formatHostHandoff(view, locale);
+        const text = [copy.title, copy.description, copy.detail, view.diagnostic]
+          .filter(Boolean)
+          .join('\n');
+        output.write(
+          '\n' +
+            stripVTControlCharacters(text).replace(/[\p{Cc}\p{Cf}]/gu, (character) =>
+              character === '\n' ? character : '\uFFFD',
+            ) +
+            '\n',
+        );
+        if (view.actions.length === 0) return;
+        const options = copy.actions.map(
+          ({ action, label }) =>
+            `${action === 'interrupt' ? 'stop' : action === 'retry' ? 'r' : 'Enter'}: ${label}`,
+        );
+        readline.setPrompt(options.join(' · ') + ' > ');
+        readline.prompt();
+      },
+      close() {
+        closed = true;
+        readline.close();
+      },
+    };
+  };
+}
diff --git a/packages/cli/src/runtime-host-lifecycle-transaction.ts b/packages/cli/src/runtime-host-lifecycle-transaction.ts
index 8015c39235..a971cdc675 100644
--- a/packages/cli/src/runtime-host-lifecycle-transaction.ts
+++ b/packages/cli/src/runtime-host-lifecycle-transaction.ts
@@ -18,6 +18,7 @@
  */
 
 import { randomUUID } from 'node:crypto';
+import { withOperatorRetirementCancellation } from './runtime-host-operator-retirement.js';
 import { isDeepStrictEqual } from 'node:util';
 import {
   resolveExistingStorageRoot,
@@ -334,6 +335,16 @@ export async function retireRuntimeHostLifecycleOwner(input: {
   readonly timeoutMs?: number;
   readonly retireIdleSupervisor?: boolean;
 }): Promise<RuntimeHostLifecycleRetirement> {
+  return withOperatorRetirementCancellation((signal) =>
+    retireRuntimeHostLifecycleOwnerWithSignal(input, signal),
+  );
+}
+
+async function retireRuntimeHostLifecycleOwnerWithSignal(
+  input: Parameters<typeof retireRuntimeHostLifecycleOwner>[0],
+  signal?: AbortSignal,
+): Promise<RuntimeHostLifecycleRetirement> {
+  signal?.throwIfAborted();
   if (input.expectedOwner && !input.supervisor) {
     throw new RuntimeHostLifecycleTransactionError(
       'owner_changed',
@@ -352,6 +363,7 @@ export async function retireRuntimeHostLifecycleOwner(input: {
         const status = await input.supervisor.status();
         assertExpectedSupervisorOwner(input.expectedOwner, status);
       }
+      signal?.throwIfAborted();
       if (input.retireIdleSupervisor !== false) await input.supervisor?.retire();
       return { kind: 'retired', owner: idleOwner };
     } catch (error) {
@@ -376,6 +388,7 @@ export async function retireRuntimeHostLifecycleOwner(input: {
       assertExpectedSupervisorOwner(input.expectedOwner, status);
       if (status.active && status.pid !== null) {
         if (!input.allowInterruptActiveTasks) return { kind: 'active_tasks' };
+        signal?.throwIfAborted();
         await input.supervisor.retire();
         return waitForRuntimeHostLifecycleOwner(capability, input.timeoutMs ?? 45_000);
       }
@@ -411,6 +424,8 @@ export async function retireRuntimeHostLifecycleOwner(input: {
       const prepared = await prepareConnectedRuntimeHostRetirement(
         connected.connection,
         input.allowInterruptActiveTasks ? 'interrupt_active_work' : 'refuse_active_work',
+        undefined,
+        signal,
       );
       if (prepared.kind === 'active_tasks') return prepared;
       if (prepared.pid !== diagnostics.pid) {
@@ -420,6 +435,7 @@ export async function retireRuntimeHostLifecycleOwner(input: {
         );
       }
     } catch (error) {
+      signal?.throwIfAborted();
       if (!isRuntimeHostRetirementUnavailable(error) || !input.supervisor) throw error;
       if (!input.allowInterruptActiveTasks) return { kind: 'active_tasks' };
       await input.supervisor.retire();
diff --git a/packages/cli/src/runtime-host-local-handoff.ts b/packages/cli/src/runtime-host-local-handoff.ts
index 12961a7998..0402e4634b 100644
--- a/packages/cli/src/runtime-host-local-handoff.ts
+++ b/packages/cli/src/runtime-host-local-handoff.ts
@@ -21,6 +21,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { realpath, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, join, posix, resolve, win32 } from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
 import {
   claimLocalHostProcessDeployment,
   handoffLocalHostProcessDeployment,
@@ -134,6 +135,7 @@ export interface RuntimeHostNpmGlobalReconciliationRequest {
 }
 
 export type RuntimeHostNpmGlobalRestartResult =
+  | { readonly kind: 'changed' }
   | LocalHostProcessDeploymentClaimResult
   | LocalHostProcessDeploymentHandoffResult
   | {
@@ -154,10 +156,13 @@ export async function restartRuntimeHostNpmGlobalDeployment(
     readonly installationOptions?: Parameters<typeof resolveRuntimeHostNpmGlobalInstallation>[0];
     readonly deploymentPathOptions?: RuntimeHostLocalDeploymentPathOptions;
     readonly activeWorkPolicy?: 'refuse_active_work' | 'interrupt_active_work';
+    readonly signal?: AbortSignal;
+    readonly expectedInstallation?: RuntimeHostNpmGlobalInstallation;
   },
   authorityOptions: LocalHostDeploymentAuthorityOptions = {},
   overrides: Partial<RuntimeHostLocalRestartDeps> = {},
 ): Promise<RuntimeHostNpmGlobalRestartResult> {
+  input.signal?.throwIfAborted();
   if (input.registration.lifecycleMode !== 'ephemeral') {
     return {
       kind: 'operator_required',
@@ -178,6 +183,9 @@ export async function restartRuntimeHostNpmGlobalDeployment(
     ...overrides,
   };
   const installation = await deps.resolveInstallation(input.installationOptions);
+  if (input.expectedInstallation && !isDeepStrictEqual(installation, input.expectedInstallation)) {
+    return { kind: 'changed' };
+  }
   const current = await deps.readRecord(input.registration.rootId, authorityOptions);
   const sourceOwner = current?.state.kind === 'handoff' ? current.state.from : current?.state.owner;
   if (sourceOwner && !sameOwner(sourceOwner, installation.owner)) {
@@ -264,6 +272,7 @@ export async function restartRuntimeHostNpmGlobalDeployment(
     stagedTarget: RuntimeHostLocalStagedDeployment,
     inheritableAuthorityLeaseFd: number,
   ): Promise<{ readonly kind: 'target_present' | 'active_work' }> => {
+    input.signal?.throwIfAborted();
     if (rootId !== input.registration.rootId) {
       throw new RuntimeHostLocalHandoffError(
         'root_changed',
@@ -327,6 +336,7 @@ export async function restartRuntimeHostNpmGlobalDeployment(
         expectedHostEpoch: registration.hostEpoch,
         activeWorkPolicy,
         inheritableAuthorityLeaseFd,
+        ...(input.signal ? { signal: input.signal } : {}),
       });
       if (retired === 'active_work') return { kind: 'active_work' };
       if (retired === 'operator_required') {
@@ -640,6 +650,25 @@ async function requireCandidateEntrypoint(packageRoot: string): Promise<string>
   return candidate;
 }
 
+/** Read-only capability check against the same verified source package the transaction uses. */
+export async function runtimeHostNpmGlobalSourceRetirementAvailable(input: {
+  readonly rootId: string;
+  readonly owner: RuntimeHostNpmGlobalInstallation['owner'];
+  readonly source: RuntimeHostUpdateCandidate;
+  readonly deploymentPathOptions?: RuntimeHostLocalDeploymentPathOptions;
+}): Promise<boolean> {
+  const source = await openRuntimeHostNpmGlobalStagedDeployment(
+    {
+      rootId: input.rootId,
+      owner: input.owner,
+      target: input.source,
+      transactionId: 'source-capability-probe',
+    },
+    input.deploymentPathOptions,
+  );
+  return hasSourceRetirementHelper(source);
+}
+
 async function hasSourceRetirementHelper(
   source: RuntimeHostLocalStagedDeployment,
 ): Promise<boolean> {
diff --git a/packages/cli/src/runtime-host-local-source-retirement.ts b/packages/cli/src/runtime-host-local-source-retirement.ts
index 390d6b0059..e589b4e22c 100644
--- a/packages/cli/src/runtime-host-local-source-retirement.ts
+++ b/packages/cli/src/runtime-host-local-source-retirement.ts
@@ -87,7 +87,9 @@ export function launchRuntimeHostLocalSourceRetirement(input: {
   readonly expectedHostEpoch: string;
   readonly activeWorkPolicy: 'refuse_active_work' | 'interrupt_active_work';
   readonly inheritableAuthorityLeaseFd: number;
+  readonly signal?: AbortSignal;
 }): Promise<'prepared' | 'active_work' | 'operator_required'> {
+  input.signal?.throwIfAborted();
   const args = [
     input.sourceCliPath,
     'runtime-host',
@@ -111,9 +113,22 @@ export function launchRuntimeHostLocalSourceRetirement(input: {
       killSignal: 'SIGKILL',
       windowsHide: false,
     });
-    child.once('error', reject);
+    // Only this retirement client is stopped, never the parent that owns the
+    // durable deployment transaction. Wait for its fd/connection to close.
+    const cancel = () => {
+      child.kill('SIGKILL');
+    };
+    input.signal?.addEventListener('abort', cancel, { once: true });
+    if (input.signal?.aborted) cancel();
+    let spawnError: Error | undefined;
+    child.once('error', (error) => {
+      spawnError = error;
+    });
     child.once('close', (code, signal) => {
-      if (signal) {
+      input.signal?.removeEventListener('abort', cancel);
+      if (spawnError) {
+        reject(spawnError);
+      } else if (signal) {
         reject(new Error(`Maka source retirement helper exited on ${signal}`));
       } else if (code === 0) {
         resolve('prepared');
diff --git a/packages/cli/src/runtime-host-managed-lifecycle-manager.ts b/packages/cli/src/runtime-host-managed-lifecycle-manager.ts
index 1a35cda4ea..87ede619d7 100644
--- a/packages/cli/src/runtime-host-managed-lifecycle-manager.ts
+++ b/packages/cli/src/runtime-host-managed-lifecycle-manager.ts
@@ -136,6 +136,7 @@ export async function manageRuntimeHostManagedLifecycle(
     }
     if (input.action === 'restart') {
       const retirement = await retireRuntimeHostLifecycleOwner({
+        ...(input.expectedHost ? { expectedOwner: input.expectedHost } : {}),
         rootPath: config.root.path,
         rootId,
         supervisor: provider.supervisor,
diff --git a/packages/cli/src/runtime-host-operator-retirement.ts b/packages/cli/src/runtime-host-operator-retirement.ts
new file mode 100644
index 0000000000..fc950ff001
--- /dev/null
+++ b/packages/cli/src/runtime-host-operator-retirement.ts
@@ -0,0 +1,57 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import type { Readable } from 'node:stream';
+import { RUNTIME_HOST_OPERATOR_RETIREMENT_CANCELLATION_ENV } from '@maka/runtime-host/operator';
+
+/** Consume the operator's one-shot cancellation channel only around reversible retirement. */
+export function withOperatorRetirementCancellation<T>(
+  operation: (signal: AbortSignal | undefined) => Promise<T>,
+): Promise<T> {
+  if (process.env[RUNTIME_HOST_OPERATOR_RETIREMENT_CANCELLATION_ENV] !== '1') {
+    return operation(undefined);
+  }
+  // Recovery may retire another owner later. It must finish independently of
+  // the original user's cancellation, and activators must not inherit this channel.
+  delete process.env[RUNTIME_HOST_OPERATOR_RETIREMENT_CANCELLATION_ENV];
+  return withRetirementCancellation(process.stdin, operation);
+}
+
+export async function withRetirementCancellation<T>(
+  input: Readable,
+  operation: (signal: AbortSignal) => Promise<T>,
+): Promise<T> {
+  const controller = new AbortController();
+  const cancel = () => controller.abort(new Error('Runtime Host retirement was cancelled'));
+  input.once('end', cancel);
+  input.once('error', cancel);
+  input.once('close', cancel);
+  input.resume();
+  if (input.readableEnded || input.destroyed) cancel();
+  try {
+    return await operation(controller.signal);
+  } finally {
+    input.removeListener('end', cancel);
+    input.removeListener('error', cancel);
+    input.removeListener('close', cancel);
+    input.pause();
+    // A parent's still-open cancellation pipe must not keep the completed CLI alive.
+    (input as Readable & { unref?: () => void }).unref?.();
+  }
+}
diff --git a/packages/cli/src/runtime-host-service-manager.ts b/packages/cli/src/runtime-host-service-manager.ts
index 96a9eadc38..117eb6b128 100644
--- a/packages/cli/src/runtime-host-service-manager.ts
+++ b/packages/cli/src/runtime-host-service-manager.ts
@@ -240,6 +240,7 @@ export interface RuntimeHostManagedServiceInput {
   readonly cliPath: string;
   readonly expectedTarget?: RuntimeHostManagedServiceTarget;
   readonly expectedConfigFingerprint?: string;
+  readonly expectedHost?: { readonly hostEpoch: string; readonly pid: number };
   readonly allowInterruptActiveTasks?: boolean;
 }
 
@@ -333,6 +334,12 @@ export async function manageRuntimeHostService(
   backend: RuntimeHostServiceBackend,
   overrides: Partial<RuntimeHostServiceManagerDeps> = {},
 ): Promise<RuntimeHostManagedServiceResult> {
+  if (input.expectedHost) {
+    throw new RuntimeHostServiceManagerError(
+      'target_mismatch',
+      'An exact Host fence requires the canonical managed deployment operator',
+    );
+  }
   const deps = runtimeHostServiceManagerDeps(overrides);
   const configPath = resolveRuntimeHostManagedServiceConfigPath(input.clientDataRoot);
   const configDirectory = dirname(configPath);
diff --git a/packages/cli/src/runtime-host-tui-command.ts b/packages/cli/src/runtime-host-tui-command.ts
index e8edf22d42..285669691f 100644
--- a/packages/cli/src/runtime-host-tui-command.ts
+++ b/packages/cli/src/runtime-host-tui-command.ts
@@ -19,19 +19,16 @@
 
 import { parseNoRealConnectionError } from '@maka/core/connection-error-copy';
 import type { UiLocale } from '@maka/core/ui-locale';
-import { createInterface } from 'node:readline/promises';
 import { SessionActivityRegistry } from '@maka/runtime/goal-turn-lifecycle';
-import { readRuntimeHostConnectionCatalog } from '@maka/runtime-host/client';
+import {
+  readRuntimeHostConnectionCatalog,
+  HostHandoffCancelledError,
+} from '@maka/runtime-host/client';
 import { runtimeHostProfileUsesHostWorkspace } from '@maka/runtime-host/profile-kind';
 import { createForeignSessionStore } from '@maka/storage/foreign-session-store';
 import { formatMakaResumeHint } from './cli-invocation.js';
-import {
-  connectRuntimeHostCli,
-  resolveRuntimeHostCliConflictDecision,
-  RuntimeHostCliConflictError,
-} from './runtime-host-cli-context.js';
-import { resolveRuntimeHostNpmGlobalInstallation } from './runtime-host-cli-installation.js';
-import { restartRuntimeHostNpmGlobalDeployment } from './runtime-host-local-handoff.js';
+import { connectRuntimeHostCli } from './runtime-host-cli-context.js';
+import { createCliHostHandoffSurface } from './runtime-host-handoff-surface.js';
 import { createRuntimeHostOnboardingSurface } from './runtime-host-onboarding.js';
 import type { MakaPiTuiTurnActivitySurface } from './pi-tui-contracts.js';
 import { runMakaPiTui } from './pi-tui-runner.js';
@@ -54,6 +51,7 @@ export interface RunRuntimeHostTuiInput {
 export async function runRuntimeHostTui(input: RunRuntimeHostTuiInput): Promise<number> {
   const foreignSessions = createForeignSessionStore();
   const contextInput = {
+    ...(process.stdin.isTTY ? { handoffSurface: createCliHostHandoffSurface(input.locale) } : {}),
     clientDataRoot: input.clientDataRoot,
     rootPath: input.workspaceRoot,
     cwd: input.cwd,
@@ -63,9 +61,9 @@ export async function runRuntimeHostTui(input: RunRuntimeHostTuiInput): Promise<
   };
   let context;
   try {
-    context = await createTuiContextWithHostConflictPrompt(contextInput);
-    if (!context) return 1;
+    context = await createRuntimeHostTuiContext(contextInput);
   } catch (error) {
+    if (error instanceof HostHandoffCancelledError) return 1;
     if (!isMissingDefaultConnection(error) || input.resumeSessionId) throw error;
     const configured = await runFirstRunOnboarding(
       input.clientDataRoot,
@@ -136,73 +134,6 @@ export async function runRuntimeHostTui(input: RunRuntimeHostTuiInput): Promise<
   }
 }
 
-async function createTuiContextWithHostConflictPrompt(
-  input: Parameters<typeof createRuntimeHostTuiContext>[0],
-): Promise<Awaited<ReturnType<typeof createRuntimeHostTuiContext>> | null> {
-  const blockedRestartEpochs = new Set<string>();
-  while (true) {
-    try {
-      return await createRuntimeHostTuiContext(input);
-    } catch (error) {
-      if (!(error instanceof RuntimeHostCliConflictError) || !process.stdin.isTTY) throw error;
-      process.stderr.write(`${error.message}\n`);
-      const canRestart =
-        error.registration.lifecycleMode === 'ephemeral' &&
-        !blockedRestartEpochs.has(error.registration.hostEpoch) &&
-        (await isPersistentNpmGlobalCli());
-      const readline = createInterface({ input: process.stdin, output: process.stderr });
-      let decision;
-      try {
-        const answer = await readline.question(
-          canRestart
-            ? 'Restart this local Host if it is idle, wait for it to exit, or cancel? [r/w/C] '
-            : 'Wait only if the existing Host is expected to exit, or cancel? [w/C] ',
-        );
-        decision = resolveRuntimeHostCliConflictDecision(answer, canRestart);
-      } finally {
-        readline.close();
-      }
-      if (decision === 'cancel') return null;
-      if (decision === 'restart') {
-        const result = await restartRuntimeHostNpmGlobalDeployment({
-          rootPath: input.rootPath,
-          registration: error.registration,
-        });
-        if (result.kind === 'completed') continue;
-        if (result.kind === 'active_work') {
-          blockedRestartEpochs.add(error.registration.hostEpoch);
-          process.stderr.write(
-            'The existing Runtime Host still owns active or durable work and was not interrupted.\n',
-          );
-          continue;
-        }
-        if (result.kind === 'operator_required') {
-          blockedRestartEpochs.add(error.registration.hostEpoch);
-          continue;
-        }
-        if (result.kind === 'rejected') continue;
-        throw new Error(`Local Runtime Host restart requires recovery at ${result.phase}`, {
-          cause: result.cause,
-        });
-      }
-      await waitForHostRetry();
-    }
-  }
-}
-
-async function isPersistentNpmGlobalCli(): Promise<boolean> {
-  try {
-    await resolveRuntimeHostNpmGlobalInstallation();
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function waitForHostRetry(): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, 2_000));
-}
-
 async function runFirstRunOnboarding(
   clientDataRoot: string,
   rootPath: string,
@@ -214,6 +145,7 @@ async function runFirstRunOnboarding(
     clientDataRoot,
     rootPath,
     interactiveSsh: true,
+    ...(process.stdin.isTTY ? { handoffSurface: createCliHostHandoffSurface(locale) } : {}),
     ...(hostProfileId ? { profileId: hostProfileId } : {}),
   });
   try {
diff --git a/packages/cli/src/runtime-host-tui-context.ts b/packages/cli/src/runtime-host-tui-context.ts
index f4456ecf1a..3965c89255 100644
--- a/packages/cli/src/runtime-host-tui-context.ts
+++ b/packages/cli/src/runtime-host-tui-context.ts
@@ -28,6 +28,7 @@ import { findProjectByIdentity } from '@maka/core/project';
 import type {
   RuntimeHostConnectionCatalogEntry as ConnectionCatalogEntry,
   RuntimeHostConnectionCatalogSnapshot as ConnectionCatalogSnapshot,
+  OpenHostHandoffSurface,
 } from '@maka/runtime-host/client';
 import { SessionActivityRegistry } from '@maka/runtime/goal-turn-lifecycle';
 import { type InvocableSkillEntry } from '@maka/runtime/skill-invocation';
@@ -118,6 +119,7 @@ export interface RuntimeHostTuiContext {
 }
 
 export interface CreateRuntimeHostTuiContextInput {
+  readonly handoffSurface?: OpenHostHandoffSurface;
   readonly clientDataRoot: string;
   readonly rootPath: string;
   readonly cwd: string;
@@ -133,6 +135,7 @@ export async function createRuntimeHostTuiContext(
     clientDataRoot: input.clientDataRoot,
     rootPath: input.rootPath,
     interactiveSsh: true,
+    ...(input.handoffSurface ? { handoffSurface: input.handoffSurface } : {}),
     ...(input.hostProfileId ? { profileId: input.hostProfileId } : {}),
   });
   const connection = connected.connection;
diff --git a/packages/core/package.json b/packages/core/package.json
index ca2c096f56..c3d8a44ce0 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -11,6 +11,8 @@
     "./model-projection-transition": "./dist/model-projection-transition.js",
     "./canonical-runtime-event": "./dist/canonical-runtime-event.js",
     "./runtime-boundary": "./dist/runtime-boundary.js",
+    "./runtime-handoff": "./dist/runtime-handoff.js",
+    "./runtime-logical-execution": "./dist/runtime-logical-execution.js",
     "./runtime-event": "./dist/runtime-event.js",
     "./tool-args-identity": "./dist/tool-args-identity.js",
     "./tool-ledger-scanner": "./dist/tool-ledger-scanner.js",
diff --git a/packages/core/src/__tests__/runtime-boundary.test.ts b/packages/core/src/__tests__/runtime-boundary.test.ts
index 4705864e6e..70b09ceac7 100644
--- a/packages/core/src/__tests__/runtime-boundary.test.ts
+++ b/packages/core/src/__tests__/runtime-boundary.test.ts
@@ -24,9 +24,10 @@ import {
   buildImmutableRuntimePrefix,
   createRuntimeBoundaryCursor,
   decodeContinuationClaim,
+  decodeRuntimeBoundaryCursor,
   invocationMatchesClaimTarget,
   runtimePrefixSegment,
-  type RuntimeBoundaryCursorV1,
+  type RuntimeBoundaryCursor,
   type RuntimePrefixIdentityV1,
 } from '../runtime-boundary.js';
 
@@ -216,7 +217,7 @@ describe('immutable RuntimeEvent boundary', () => {
     assert.throws(() => createRuntimeBoundaryCursor([first, second]), /duplicate invocationId/);
   });
 
-  it('rejects a boundary that reuses a source turn identity', () => {
+  it('versions consecutive same-turn physical attempts without weakening released cursors', () => {
     const firstIdentity = runtimeIdentity('run-first');
     const secondIdentity = {
       ...runtimeIdentity('run-second'),
@@ -233,7 +234,52 @@ describe('immutable RuntimeEvent boundary', () => {
       ]),
     );
 
-    assert.throws(() => createRuntimeBoundaryCursor([first, second]), /duplicate turnId/);
+    const cursor = createRuntimeBoundaryCursor([first, second]);
+    assert.equal(cursor.protocol, 'runtime_boundary_cursor_v2');
+    assert.deepEqual(decodeRuntimeBoundaryCursor(cursor), cursor);
+    assert.throws(
+      () => decodeRuntimeBoundaryCursor({ ...cursor, protocol: 'runtime_boundary_cursor_v1' }),
+      /version mismatch/,
+    );
+    const other = boundaryForRuns('other').segments[0];
+    assert.throws(() => createRuntimeBoundaryCursor([first, other, second]), /previous turnId/);
+  });
+
+  it('permits same-turn claims only for explicit handoff to the original logical root', () => {
+    const boundary = boundaryForRuns('run-source');
+    const manual = claimForBoundary(boundary);
+    const handoff = {
+      ...manual,
+      target: { ...manual.target, turnId: boundary.segments[0].identity.turnId },
+      targetOpening: {
+        ...manual.targetOpening,
+        source: {
+          ...manual.targetOpening.source,
+          kind: 'handoff',
+          rootRunId: 'run-source',
+        },
+      },
+    };
+    assert.equal(decodeContinuationClaim(handoff).targetOpening.source.kind, 'handoff');
+    assert.throws(
+      () => decodeContinuationClaim({ ...handoff, targetOpening: manual.targetOpening }),
+      /turnId reuses/,
+    );
+    assert.throws(
+      () => decodeContinuationClaim({ ...handoff, target: manual.target }),
+      /preserve the logical turnId/,
+    );
+    assert.throws(
+      () =>
+        decodeContinuationClaim({
+          ...handoff,
+          targetOpening: {
+            ...handoff.targetOpening,
+            source: { ...handoff.targetOpening.source, rootRunId: 'foreign' },
+          },
+        }),
+      /logical root mismatch/,
+    );
   });
 
   it('requires a continuation target to remain in the source session', () => {
@@ -375,7 +421,7 @@ function event(
   };
 }
 
-function boundaryForRuns(...runIds: string[]): RuntimeBoundaryCursorV1 {
+function boundaryForRuns(...runIds: string[]): RuntimeBoundaryCursor {
   const segments = runIds.map((runId) => {
     const identity = runtimeIdentity(runId);
     return runtimePrefixSegment(
@@ -387,7 +433,7 @@ function boundaryForRuns(...runIds: string[]): RuntimeBoundaryCursorV1 {
   return createRuntimeBoundaryCursor(segments);
 }
 
-function claimForBoundary(boundary: RuntimeBoundaryCursorV1) {
+function claimForBoundary(boundary: RuntimeBoundaryCursor) {
   const source = boundary.segments.at(-1)!;
   const target = {
     sessionId: boundary.segments[0].identity.sessionId,
diff --git a/packages/core/src/__tests__/runtime-handoff.test.ts b/packages/core/src/__tests__/runtime-handoff.test.ts
new file mode 100644
index 0000000000..ee163e37cd
--- /dev/null
+++ b/packages/core/src/__tests__/runtime-handoff.test.ts
@@ -0,0 +1,97 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import assert from 'node:assert/strict';
+import { encodeCanonicalRuntimeEvent } from '../canonical-runtime-event.js';
+import { test } from 'node:test';
+import { decodeRuntimeEvent, isTerminalRuntimeEvent, type RuntimeEvent } from '../runtime-event.js';
+import { runtimeInvocationOutcome } from '../runtime-invocation.js';
+import { runtimeHandoffPause } from '../runtime-handoff.js';
+
+const paused: RuntimeEvent = {
+  id: 'pause',
+  invocationId: 'physical-1',
+  runId: 'physical-1',
+  sessionId: 'session',
+  turnId: 'logical-turn',
+  ts: 1,
+  partial: false,
+  role: 'system',
+  author: 'host',
+  actions: {
+    endInvocation: true,
+    handoffPause: {
+      protocol: 'runtime_handoff_pause_v1',
+      handoffId: 'handoff',
+      hostEpoch: 'source-host',
+      remainingSteps: null,
+      rootRunId: 'physical-1',
+      successorRunId: 'physical-2',
+      successorInvocationId: 'physical-2',
+      claimId: 'exact-claim',
+    },
+  },
+};
+
+test('a handoff seals a physical invocation without ending its logical execution', () => {
+  const event = decodeRuntimeEvent(paused);
+  assert.equal(isTerminalRuntimeEvent(event), true);
+  assert.equal(runtimeInvocationOutcome({ terminalEvent: event }), undefined);
+  assert.equal(runtimeHandoffPause(event)?.successorRunId, 'physical-2');
+  const frozen = Object.freeze({ ...event, actions: Object.freeze({ ...event.actions }) });
+  assert.deepEqual(encodeCanonicalRuntimeEvent(frozen).event, event);
+});
+
+test('a handoff seal cannot claim completion, carry work, or authorize itself as successor', () => {
+  for (const invalid of [
+    ...[0, -1, 1.5, undefined, Number.MAX_SAFE_INTEGER + 1].map((remainingSteps) => ({
+      ...paused,
+      actions: {
+        ...paused.actions,
+        handoffPause: { ...paused.actions!.handoffPause, remainingSteps },
+      },
+    })),
+    { ...paused, status: 'completed' },
+    { ...paused, partial: true },
+    { ...paused, content: { kind: 'text', text: 'work' } },
+    { ...paused, actions: { ...paused.actions, toolDispatch: {} } },
+    { ...paused, actions: { ...paused.actions, endInvocation: false } },
+    {
+      ...paused,
+      actions: {
+        ...paused.actions,
+        handoffPause: {
+          ...paused.actions!.handoffPause,
+          successorRunId: paused.runId,
+        },
+      },
+    },
+    {
+      ...paused,
+      actions: {
+        ...paused.actions,
+        handoffPause: {
+          ...paused.actions!.handoffPause,
+          unrecognizedAuthority: true,
+        },
+      },
+    },
+  ])
+    assert.throws(() => decodeRuntimeEvent(invalid));
+});
diff --git a/packages/core/src/backend-types.ts b/packages/core/src/backend-types.ts
index 18f4383c2a..d0aa76221f 100644
--- a/packages/core/src/backend-types.ts
+++ b/packages/core/src/backend-types.ts
@@ -63,7 +63,7 @@ export interface BackendSendInput {
   /** Caller-generated turn id shared by the persisted UserMessage and every emitted event. */
   turnId: string;
   /** Trusted per-turn cap on provider tool-call steps. */
-  maxSteps?: number;
+  maxSteps?: number | null;
   /** Trusted effective orchestration snapshot for this run. */
   orchestration?: EffectiveOrchestration;
   /** Trusted per-run tool protocol override. Direct remains the default. */
@@ -98,6 +98,14 @@ export interface BackendSendInput {
   runtimeContextInvocations?: readonly RuntimeInvocationRecord[];
   /** Continue from an already committed RuntimeEvent boundary without adding another user turn. */
   continuation?: RuntimeContinuationMetadata;
+  /** Runtime-owned reversible gate, called only before another provider step,
+   * after the preceding provider/tool events have been durably consumed.
+   * `pause` ends this physical stream without emitting logical completion.
+   */
+  handoffBoundary?: (
+    signal: AbortSignal,
+    remainingSteps: number | null,
+  ) => Promise<'continue' | 'pause'>;
   /**
    * Steering pull — a LEASE, and the single atomic commit point of delivery.
    * Backends that support mid-turn steering call this at every step boundary;
diff --git a/packages/core/src/canonical-runtime-event.ts b/packages/core/src/canonical-runtime-event.ts
index ea9b8ddde3..a076697bd4 100644
--- a/packages/core/src/canonical-runtime-event.ts
+++ b/packages/core/src/canonical-runtime-event.ts
@@ -112,7 +112,9 @@ function omitUndefinedEnvelopeFields(value: object): object {
       throw new Error('RuntimeEvent is not losslessly serializable');
     }
     if (descriptor.value === undefined) continue;
-    Object.defineProperty(result, key, descriptor);
+    // This is our normalization copy. Frozen snapshots constrain their owner,
+    // not this copy; retaining non-configurable flags prevents normalizing it.
+    Object.defineProperty(result, key, { ...descriptor, configurable: true, writable: true });
   }
   return result;
 }
diff --git a/packages/core/src/runtime-boundary.ts b/packages/core/src/runtime-boundary.ts
index 8d9ff1ae68..401cddf9f6 100644
--- a/packages/core/src/runtime-boundary.ts
+++ b/packages/core/src/runtime-boundary.ts
@@ -66,11 +66,20 @@ export interface RuntimeBoundaryCursorV1 {
   manifestDigest: RuntimeBoundaryDigest;
 }
 
+/** V2 permits consecutive physical attempts of the same logical Turn.
+ * Segment digests identify the facts; the authority must authenticate every edge.
+ */
+export interface RuntimeBoundaryCursorV2 extends Omit<RuntimeBoundaryCursorV1, 'protocol'> {
+  protocol: 'runtime_boundary_cursor_v2';
+}
+
+export type RuntimeBoundaryCursor = RuntimeBoundaryCursorV1 | RuntimeBoundaryCursorV2;
+
 export interface ContinuationClaimV1 {
   protocol: 'continuation_claim_v1';
   claimId: string;
   boundaryDigest: RuntimeBoundaryDigest;
-  boundary: RuntimeBoundaryCursorV1;
+  boundary: RuntimeBoundaryCursor;
   providerProjectionVersion: 1 | 2;
   providerReplayDigest: RuntimeBoundaryDigest;
   target: {
@@ -143,7 +152,7 @@ export function runtimePrefixSegment(prefix: ImmutableRuntimePrefixV1): RuntimeP
 
 export function createRuntimeBoundaryCursor(
   segments: readonly [RuntimePrefixSegmentV1, ...RuntimePrefixSegmentV1[]],
-): RuntimeBoundaryCursorV1 {
+): RuntimeBoundaryCursor {
   const canonicalSegments = segments.map(decodeRuntimePrefixSegment) as [
     RuntimePrefixSegmentV1,
     ...RuntimePrefixSegmentV1[],
@@ -152,6 +161,8 @@ export function createRuntimeBoundaryCursor(
   const invocationIds = new Set<string>();
   const runIds = new Set<string>();
   const turnIds = new Set<string>();
+  let previousTurnId: string | undefined;
+  let protocol: RuntimeBoundaryCursor['protocol'] = 'runtime_boundary_cursor_v1';
   for (const segment of canonicalSegments) {
     if (segment.identity.sessionId !== sessionId) {
       throw new Error('Runtime boundary segments must belong to the same session');
@@ -165,27 +176,40 @@ export function createRuntimeBoundaryCursor(
     }
     invocationIds.add(segment.identity.invocationId);
     if (turnIds.has(segment.identity.turnId)) {
-      throw new Error('Runtime boundary lineage contains a duplicate turnId');
+      if (previousTurnId !== segment.identity.turnId) {
+        throw new Error('Runtime boundary lineage returns to a previous turnId');
+      }
+      protocol = 'runtime_boundary_cursor_v2';
     }
     turnIds.add(segment.identity.turnId);
+    previousTurnId = segment.identity.turnId;
   }
   return {
-    protocol: 'runtime_boundary_cursor_v1',
+    protocol,
     segments: canonicalSegments,
-    manifestDigest: digestRuntimeBoundaryManifest(canonicalSegments),
+    manifestDigest: digestRuntimeBoundaryManifest(canonicalSegments, protocol),
   };
 }
 
 export function digestRuntimeBoundaryManifest(
   segments: readonly [RuntimePrefixSegmentV1, ...RuntimePrefixSegmentV1[]],
+  protocol: RuntimeBoundaryCursor['protocol'] = 'runtime_boundary_cursor_v1',
 ): RuntimeBoundaryDigest {
   const canonicalSegments = segments.map(decodeRuntimePrefixSegment);
   const json = stableJsonStringify({
-    protocol: 'runtime_boundary_cursor_v1',
+    protocol,
     segments: canonicalSegments,
   });
   const hash = nodeCrypto.createHash('sha256');
-  updateLengthPrefixed(hash, Buffer.from('maka.runtime-boundary-manifest.v1', 'utf8'));
+  updateLengthPrefixed(
+    hash,
+    Buffer.from(
+      protocol === 'runtime_boundary_cursor_v1'
+        ? 'maka.runtime-boundary-manifest.v1'
+        : 'maka.runtime-boundary-manifest.v2',
+      'utf8',
+    ),
+  );
   updateLengthPrefixed(hash, Buffer.from(json, 'utf8'));
   return `sha256:${hash.digest('hex')}`;
 }
@@ -206,11 +230,12 @@ export function decodeRuntimePrefixSegment(value: unknown): RuntimePrefixSegment
   };
 }
 
-export function decodeRuntimeBoundaryCursor(value: unknown): RuntimeBoundaryCursorV1 {
+export function decodeRuntimeBoundaryCursor(value: unknown): RuntimeBoundaryCursor {
   if (
     !isRecord(value) ||
     !hasExactKeys(value, ['protocol', 'segments', 'manifestDigest']) ||
-    value.protocol !== 'runtime_boundary_cursor_v1' ||
+    (value.protocol !== 'runtime_boundary_cursor_v1' &&
+      value.protocol !== 'runtime_boundary_cursor_v2') ||
     !Array.isArray(value.segments) ||
     value.segments.length === 0
   ) {
@@ -221,6 +246,8 @@ export function decodeRuntimeBoundaryCursor(value: unknown): RuntimeBoundaryCurs
     ...RuntimePrefixSegmentV1[],
   ];
   const cursor = createRuntimeBoundaryCursor(segments);
+  if (cursor.protocol !== value.protocol)
+    throw new Error('RuntimeEvent boundary cursor version mismatch');
   const manifestDigest = decodeBoundaryDigest(value.manifestDigest);
   if (cursor.manifestDigest !== manifestDigest) {
     throw new Error('RuntimeEvent boundary manifest digest mismatch');
@@ -275,13 +302,21 @@ export function decodeContinuationClaim(value: unknown): ContinuationClaimV1 {
     throw new Error('Continuation claim target invocationId reuses source identity');
   }
   const targetTurnId = value.target.turnId;
-  if (boundary.segments.some((segment) => segment.identity.turnId === targetTurnId)) {
-    throw new Error('Continuation claim target turnId reuses source identity');
-  }
   const targetOpening = decodeRuntimeInvocationOpened(value.targetOpening);
   const openSource = targetOpening.source;
+  if (openSource.kind === 'handoff') {
+    if (targetTurnId !== source.identity.turnId) {
+      throw new Error('Handoff claim must preserve the logical turnId');
+    }
+    const root = boundary.segments.find((segment) => segment.identity.turnId === targetTurnId);
+    if (root?.identity.runId !== openSource.rootRunId) {
+      throw new Error('Handoff claim logical root mismatch');
+    }
+  } else if (boundary.segments.some((segment) => segment.identity.turnId === targetTurnId)) {
+    throw new Error('Continuation claim target turnId reuses source identity');
+  }
   if (
-    openSource.kind !== 'continuation' ||
+    (openSource.kind !== 'continuation' && openSource.kind !== 'handoff') ||
     openSource.claimId !== value.claimId ||
     openSource.boundaryDigest !== boundaryDigest ||
     openSource.sourceInvocationId !== source.identity.invocationId ||
diff --git a/packages/core/src/runtime-event.ts b/packages/core/src/runtime-event.ts
index 8323d289b4..836506e71e 100644
--- a/packages/core/src/runtime-event.ts
+++ b/packages/core/src/runtime-event.ts
@@ -33,6 +33,11 @@
  * projection, or ledger logic lives here. Those arrive in later nodes.
  */
 
+import {
+  isRuntimeHandoffPause,
+  runtimeHandoffPause,
+  type RuntimeHandoffPause,
+} from './runtime-handoff.js';
 import {
   isMessageContent,
   normalizeMessageContent,
@@ -305,6 +310,17 @@ export type RuntimeInvocationOpenSource =
       sourceRuntimeEventHighWater: number;
       claimId?: string;
       boundaryDigest?: `sha256:${string}`;
+    }
+  | {
+      /** A new physical attempt under the original logical Turn admission. */
+      kind: 'handoff';
+      rootRunId: string;
+      sourceInvocationId: string;
+      sourceRunId: string;
+      sourceTurnId: string;
+      sourceRuntimeEventHighWater: number;
+      claimId: string;
+      boundaryDigest: `sha256:${string}`;
     };
 
 /**
@@ -489,6 +505,8 @@ export interface RuntimeEventPermissionClosureAccepted {
  * event without `actions.endInvocation` MUST assert a terminal `status`.
  */
 export interface RuntimeEventActions {
+  /** Durable physical pause; does not complete or cancel the owning logical Turn. */
+  handoffPause?: RuntimeHandoffPause;
   /** Patch applied to invocation-scoped runtime state. */
   stateDelta?: Record<string, unknown>;
   /** Artifact key → primitive delta (size/bytes/version counters, etc.). */
@@ -744,6 +762,21 @@ const INVOCATION_CONTINUATION_SOURCE_SHAPE = defineObjectShape<
 const INVOCATION_FRESH_SOURCE_SHAPE = defineObjectShape<
   Extract<RuntimeInvocationOpenSource, { kind: 'fresh' }>
 >()(['kind'], []);
+const INVOCATION_HANDOFF_SOURCE_SHAPE = defineObjectShape<
+  Extract<RuntimeInvocationOpenSource, { kind: 'handoff' }>
+>()(
+  [
+    'kind',
+    'rootRunId',
+    'sourceInvocationId',
+    'sourceRunId',
+    'sourceTurnId',
+    'sourceRuntimeEventHighWater',
+    'claimId',
+    'boundaryDigest',
+  ],
+  [],
+);
 const INVOCATION_ROOT_SHAPES = {
   user: defineObjectShape<Extract<RuntimeInvocationRootAuthority, { kind: 'user' }>>()(
     ['kind'],
@@ -769,6 +802,7 @@ const INVOCATION_ROOT_SHAPES = {
 const RUNTIME_ACTIONS_SHAPE = defineObjectShape<RuntimeEventActions>()(
   [],
   [
+    'handoffPause',
     'stateDelta',
     'artifactDelta',
     'permissionRequest',
@@ -933,6 +967,7 @@ export function decodeRuntimeEvent(value: unknown): RuntimeEvent {
   ) {
     throw new Error('Invalid RuntimeEvent schema');
   }
+  runtimeHandoffPause(value as unknown as RuntimeEvent);
   if (isRecord(value.content) && value.content.kind === 'text') {
     return {
       ...value,
@@ -1134,8 +1169,14 @@ function isRuntimeInvocationOpenSource(value: unknown): value is RuntimeInvocati
   if (!isRecord(value)) return false;
   if (value.kind === 'fresh') return hasExactShape(value, INVOCATION_FRESH_SOURCE_SHAPE);
   return (
-    value.kind === 'continuation' &&
-    hasExactShape(value, INVOCATION_CONTINUATION_SOURCE_SHAPE) &&
+    ((value.kind === 'continuation' &&
+      hasExactShape(value, INVOCATION_CONTINUATION_SOURCE_SHAPE)) ||
+      (value.kind === 'handoff' &&
+        hasExactShape(value, INVOCATION_HANDOFF_SOURCE_SHAPE) &&
+        isNonEmptyString(value.rootRunId) &&
+        isNonEmptyString(value.claimId) &&
+        isSha256Digest(value.boundaryDigest) &&
+        (value.sourceRuntimeEventHighWater as number) > 0)) &&
     isNonEmptyString(value.sourceInvocationId) &&
     isNonEmptyString(value.sourceRunId) &&
     isNonEmptyString(value.sourceTurnId) &&
@@ -1188,6 +1229,7 @@ function isRuntimeEventActions(value: unknown): value is RuntimeEventActions {
     return false;
   }
   return (
+    (value.handoffPause === undefined || isRuntimeHandoffPause(value.handoffPause)) &&
     (value.stateDelta === undefined || isRecord(value.stateDelta)) &&
     (value.artifactDelta === undefined ||
       (isRecord(value.artifactDelta) &&
diff --git a/packages/core/src/runtime-handoff.ts b/packages/core/src/runtime-handoff.ts
new file mode 100644
index 0000000000..be371329b0
--- /dev/null
+++ b/packages/core/src/runtime-handoff.ts
@@ -0,0 +1,137 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { defineObjectShape, hasExactShape, isRecord } from './record-schema.js';
+import type { RuntimeEvent } from './runtime-event.js';
+import type { ContinuationClaimV1, ImmutableRuntimePrefixV1 } from './runtime-boundary.js';
+import { stableJsonStringify } from './tool-args-identity.js';
+
+/**
+ * A physical invocation's final fact, not completion of its logical Turn.
+ * Root admission remains the execution authority. This seal authorizes exactly
+ * one successor physical attempt, claimed only when it is actually dispatched.
+ */
+export interface RuntimeHandoffPause {
+  readonly protocol: 'runtime_handoff_pause_v1';
+  readonly handoffId: string;
+  readonly hostEpoch: string;
+  readonly rootRunId: string;
+  readonly successorRunId: string;
+  readonly successorInvocationId: string;
+  readonly claimId: string;
+  /** Runtime-observed budget for the successor; null means unbounded. */
+  readonly remainingSteps: number | null;
+}
+
+export type RuntimeHandoffIntent = Omit<RuntimeHandoffPause, 'remainingSteps'>;
+
+const PAUSE_SHAPE = defineObjectShape<RuntimeHandoffPause>()(
+  [
+    'protocol',
+    'handoffId',
+    'hostEpoch',
+    'rootRunId',
+    'successorRunId',
+    'successorInvocationId',
+    'claimId',
+    'remainingSteps',
+  ],
+  [],
+);
+
+export function isRuntimeHandoffPause(value: unknown): value is RuntimeHandoffPause {
+  return (
+    isRecord(value) &&
+    hasExactShape(value, PAUSE_SHAPE) &&
+    value.protocol === 'runtime_handoff_pause_v1' &&
+    (value.remainingSteps === null ||
+      (Number.isSafeInteger(value.remainingSteps) && (value.remainingSteps as number) > 0)) &&
+    [
+      value.handoffId,
+      value.hostEpoch,
+      value.rootRunId,
+      value.successorRunId,
+      value.successorInvocationId,
+      value.claimId,
+    ].every(
+      (id) =>
+        typeof id === 'string' &&
+        id.length > 0 &&
+        id.length <= 256 &&
+        !/[\u0000-\u001f\u007f]/u.test(id),
+    )
+  );
+}
+
+/** The seal cannot simultaneously publish content or claim a logical outcome. */
+export function runtimeHandoffPause(event: RuntimeEvent): RuntimeHandoffPause | undefined {
+  const pause = event.actions?.handoffPause;
+  if (pause === undefined) return undefined;
+  if (
+    !isRuntimeHandoffPause(pause) ||
+    event.partial !== false ||
+    event.role !== 'system' ||
+    (event.author !== 'host' && event.author !== 'system') ||
+    event.status !== undefined ||
+    event.content !== undefined ||
+    event.actions?.endInvocation !== true ||
+    Object.keys(event.actions).some((key) => key !== 'endInvocation' && key !== 'handoffPause') ||
+    pause.successorRunId === event.runId ||
+    pause.successorRunId === event.invocationId ||
+    pause.successorInvocationId === event.invocationId ||
+    pause.successorRunId === pause.rootRunId
+  ) {
+    throw new Error('Invalid Runtime handoff pause seal');
+  }
+  return pause;
+}
+
+/** Verify against source facts, not the proposed claim's description of them. */
+export function assertHandoffClaimSource(
+  claim: ContinuationClaimV1,
+  prefix: ImmutableRuntimePrefixV1,
+): void {
+  const last = prefix.events.at(-1);
+  const pause = last && runtimeHandoffPause(last);
+  const source = claim.targetOpening.source;
+  if (source.kind !== 'handoff') {
+    if (pause) throw new Error('A handoff pause is reserved for its authorized successor');
+    return;
+  }
+  const opening = prefix.events[0]?.content;
+  if (
+    !pause ||
+    opening?.kind !== 'invocation_opened' ||
+    prefix.identity.sessionId !== claim.target.sessionId ||
+    prefix.identity.turnId !== claim.target.turnId ||
+    pause.claimId !== claim.claimId ||
+    pause.successorRunId !== claim.target.runId ||
+    pause.successorInvocationId !== claim.target.invocationId ||
+    pause.rootRunId !== source.rootRunId ||
+    pause.rootRunId !==
+      (opening.source.kind === 'handoff' ? opening.source.rootRunId : prefix.identity.runId) ||
+    stableJsonStringify(opening.root) !== stableJsonStringify(claim.targetOpening.root) ||
+    stableJsonStringify(opening.configuration) !==
+      stableJsonStringify(claim.targetOpening.configuration) ||
+    stableJsonStringify(opening.lineage ?? null) !==
+      stableJsonStringify(claim.targetOpening.lineage ?? null)
+  ) {
+    throw new Error('Handoff claim does not preserve the sealed source authority');
+  }
+}
diff --git a/packages/core/src/runtime-invocation.ts b/packages/core/src/runtime-invocation.ts
index e020d7f14f..9108319565 100644
--- a/packages/core/src/runtime-invocation.ts
+++ b/packages/core/src/runtime-invocation.ts
@@ -228,7 +228,7 @@ export function isSessionInlineInvocation(opening: RuntimeEventInvocationOpenedC
   const lineage = opening.lineage;
   return (
     lineage?.parentRunId === undefined ||
-    (opening.source.kind === 'continuation' && lineage.agentId === undefined)
+    (opening.source.kind !== 'fresh' && lineage.agentId === undefined)
   );
 }
 
diff --git a/packages/core/src/runtime-logical-execution.ts b/packages/core/src/runtime-logical-execution.ts
new file mode 100644
index 0000000000..954f8c9e46
--- /dev/null
+++ b/packages/core/src/runtime-logical-execution.ts
@@ -0,0 +1,159 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import {
+  continuationStartEventMatchesClaim,
+  createRuntimeBoundaryCursor,
+  invocationMatchesClaimTarget,
+  runtimePrefixSegment,
+  type RuntimePrefixSegmentV1,
+} from './runtime-boundary.js';
+import type { RuntimeEvent } from './runtime-event.js';
+import {
+  readRunInvocation,
+  type RuntimeContinuationAuthorityStore,
+} from './runtime-event-store.js';
+import type { RuntimeInvocationRecord } from './runtime-invocation.js';
+import {
+  assertHandoffClaimSource,
+  runtimeHandoffPause,
+  type RuntimeHandoffPause,
+} from './runtime-handoff.js';
+
+export interface LogicalRuntimeExecution {
+  /** Original admission identity; callers continue to validate its domain owner. */
+  readonly root: RuntimeInvocationRecord;
+  /** Latest authenticated physical attempt, never a new logical admission. */
+  readonly tip: RuntimeInvocationRecord;
+  readonly events: readonly RuntimeEvent[];
+  /** Authenticated physical membership, including the original admission. */
+  readonly runIds: readonly string[];
+  /** Durable intent exists but the successor has not opened yet. */
+  readonly pendingHandoff?: RuntimeHandoffPause;
+}
+
+type LogicalExecutionReader = Pick<
+  RuntimeContinuationAuthorityStore,
+  | 'readRunInvocation'
+  | 'listSessionInvocations'
+  | 'readImmutableRuntimeEvents'
+  | 'readImmutableRuntimePrefix'
+  | 'readContinuationClaimStateByBoundary'
+>;
+
+/** All logical snapshot and command routing paths share these edge checks. */
+export async function readLogicalRuntimeExecution(
+  store: LogicalExecutionReader,
+  identity: { sessionId: string; runId: string; turnId: string },
+  knownRoot?: RuntimeInvocationRecord,
+): Promise<LogicalRuntimeExecution | undefined> {
+  const root = knownRoot ?? (await readRunInvocation(store, identity.sessionId, identity.runId));
+  if (!root) return undefined;
+  if (
+    root.sessionId !== identity.sessionId ||
+    root.runId !== identity.runId ||
+    root.turnId !== identity.turnId ||
+    root.opening.source.kind === 'handoff'
+  ) {
+    throw new Error('Logical execution reference does not name its original admission');
+  }
+  let tip = root;
+  let segments: RuntimePrefixSegmentV1[] | undefined;
+  const seen = new Set<string>();
+  for (;;) {
+    if (seen.has(tip.runId) || seen.size >= 64)
+      throw new Error('Invalid logical execution handoff lineage');
+    seen.add(tip.runId);
+    const events = await store.readImmutableRuntimeEvents(identity.sessionId, tip.runId);
+    const last = events.at(-1);
+    const pause = last && runtimeHandoffPause(last);
+    if (!pause) return { root, tip, events, runIds: [...seen] };
+    if (pause.rootRunId !== root.runId) throw new Error('Handoff seal changes the logical root');
+    const prefix = await store.readImmutableRuntimePrefix({
+      sessionId: identity.sessionId,
+      runId: tip.runId,
+    });
+    if (prefix.position.lastEventId !== last.id)
+      throw new Error('Handoff source changed after its seal');
+    if (!segments) {
+      // A manual continuation may itself become a handoff root. Preserve its
+      // earlier replay boundary without treating those earlier Turns as this Turn.
+      const source = root.opening.source;
+      if (source.kind === 'continuation') {
+        if (!source.boundaryDigest)
+          throw new Error('Handoff requires authenticated source lineage');
+        const initial = await store.readContinuationClaimStateByBoundary(source.boundaryDigest);
+        if (
+          !initial ||
+          initial.startEventId !== prefix.events[0]?.id ||
+          !invocationMatchesClaimTarget(root, initial.claim) ||
+          !continuationStartEventMatchesClaim(prefix.events[0], initial.claim, initial.startKind)
+        ) {
+          throw new Error('Handoff root continuation is not authenticated');
+        }
+        segments = [...initial.claim.boundary.segments];
+      } else segments = [];
+    }
+    segments.push(runtimePrefixSegment(prefix));
+    const boundary = createRuntimeBoundaryCursor(
+      segments as [RuntimePrefixSegmentV1, ...RuntimePrefixSegmentV1[]],
+    );
+    let state = await store.readContinuationClaimStateByBoundary(boundary.manifestDigest);
+    const next = await readRunInvocation(store, identity.sessionId, pause.successorRunId);
+    // A start can commit between the two reads. Authority is monotonic; refresh
+    // it once when the later opening read proves the earlier snapshot was old.
+    if (next && !state?.startEventId) {
+      state = await store.readContinuationClaimStateByBoundary(boundary.manifestDigest);
+    }
+    if (!state) {
+      if (next) throw new Error('Handoff successor opened without its continuation claim');
+      return { root, tip, events, runIds: [...seen], pendingHandoff: pause };
+    }
+    assertHandoffClaimSource(state.claim, prefix);
+    if (!next) {
+      if (state.startEventId) throw new Error('Handoff successor opening is missing');
+      return { root, tip, events, runIds: [...seen], pendingHandoff: pause };
+    }
+    const first = (await store.readImmutableRuntimeEvents(identity.sessionId, next.runId))[0];
+    if (
+      state.startEventId !== first?.id ||
+      !invocationMatchesClaimTarget(next, state.claim) ||
+      !continuationStartEventMatchesClaim(first, state.claim, state.startKind)
+    ) {
+      throw new Error('Handoff successor does not match its authenticated start');
+    }
+    tip = next;
+  }
+}
+
+/** Resolve a durable physical proof back to its root, then authenticate membership. */
+export async function readLogicalRuntimeExecutionForRun(
+  store: LogicalExecutionReader,
+  identity: { sessionId: string; runId: string; turnId: string },
+): Promise<LogicalRuntimeExecution | undefined> {
+  const run = await readRunInvocation(store, identity.sessionId, identity.runId);
+  if (!run) return undefined;
+  const rootRunId =
+    run.opening.source.kind === 'handoff' ? run.opening.source.rootRunId : run.runId;
+  const logical = await readLogicalRuntimeExecution(store, { ...identity, runId: rootRunId });
+  if (!logical?.runIds.includes(identity.runId)) {
+    throw new Error('Physical proof is not an authenticated member of its logical execution');
+  }
+  return logical;
+}
diff --git a/packages/runtime-host/src/__tests__/canonical-session-projection.test.ts b/packages/runtime-host/src/__tests__/canonical-session-projection.test.ts
index c6b436436c..a5f679a05a 100644
--- a/packages/runtime-host/src/__tests__/canonical-session-projection.test.ts
+++ b/packages/runtime-host/src/__tests__/canonical-session-projection.test.ts
@@ -606,6 +606,7 @@ function createMessages(
     hostEpoch: 'epoch-1',
     root,
     durableProof: {
+      readLogicalExecution: async () => undefined,
       readRootTurnSourceMessageReceipt: (requestedSessionId, messageId) =>
         stores.agentRunStore.readRootTurnSourceMessageReceipt(requestedSessionId, messageId),
       readImmutableSteeringMessageProof: (requestedSessionId, messageId) =>
diff --git a/packages/runtime-host/src/__tests__/connection-session.test.ts b/packages/runtime-host/src/__tests__/connection-session.test.ts
index 67a35a2b28..e7fee22e49 100644
--- a/packages/runtime-host/src/__tests__/connection-session.test.ts
+++ b/packages/runtime-host/src/__tests__/connection-session.test.ts
@@ -661,78 +661,91 @@ test('a connection accepted before composition exists resolves ready handlers wi
   }
 });
 
-test('connection reset while operation admission is pending does not execute the handler', async () => {
-  const pair = await openTransportPair();
-  const admissionEntered = deferred();
-  const releaseAdmission = deferred();
-  const teardownObserved = deferred();
-  let handlerCalls = 0;
-  let finishCalls = 0;
-  const handlers: OperationHandlerMap = {
-    'host.status': async () => ({
-      ok: true,
-      result: {
-        hostEpoch: 'host-epoch',
-        compositionId: 'maka.interactive',
-        compositionRevision: '1',
-        state: 'ready',
-        connections: 1,
-        activeOperations: 1,
-        activeResidencies: 0,
-      },
-    }),
-    ...UNUSED_HOST_DIAGNOSTICS_HANDLER,
-    ...createUnavailableHostCoreOperationHandlers(),
-    ...createHandlers(async (input) => {
-      handlerCalls += 1;
-      return {
+for (const closure of ['reset', 'eof'] as const) {
+  test(`connection ${closure} during operation admission preserves closure evidence`, async () => {
+    const pair = await openTransportPair();
+    const admissionEntered = deferred();
+    const releaseAdmission = deferred();
+    const teardownObserved = deferred();
+    let handlerCalls = 0;
+    let finishCalls = 0;
+    const handlers: OperationHandlerMap = {
+      'host.status': async () => ({
         ok: true,
-        result: runningSnapshot(input.sessionId, input.turnId),
-      };
-    }),
-  };
-  const session = new RuntimeHostConnectionSession({
-    transport: pair.serverTransport,
-    connection: acceptedConnection('pending-admission'),
-    resolveHandlers: () => handlers,
-    resolveContinuity: () => undefined,
-    beginOperation: async () => {
-      admissionEntered.resolve();
-      await releaseAdmission.promise;
-      return {
-        acquireResidency: () => ({ release() {} }),
-        seal() {},
-        finish() {
-          finishCalls += 1;
+        result: {
+          hostEpoch: 'host-epoch',
+          compositionId: 'maka.interactive',
+          compositionRevision: '1',
+          state: 'ready',
+          connections: 1,
+          activeOperations: 1,
+          activeResidencies: 0,
         },
-      };
-    },
-    onTeardown: () => teardownObserved.resolve(),
-  });
-  const run = session.run();
-  try {
-    await writeProtocolFrame(pair.clientTransport, {
-      requestId: 'pending-request',
-      operation: 'turn.query',
-      input: { sessionId: 'session', turnId: 'turn' },
+      }),
+      ...UNUSED_HOST_DIAGNOSTICS_HANDLER,
+      ...createUnavailableHostCoreOperationHandlers(),
+      ...createHandlers(async (input, context) => {
+        handlerCalls += 1;
+        assert.equal(context.inputClosedSignal?.aborted, true);
+        return {
+          ok: true,
+          result: runningSnapshot(input.sessionId, input.turnId),
+        };
+      }),
+    };
+    const session = new RuntimeHostConnectionSession({
+      transport: pair.serverTransport,
+      connection: acceptedConnection('pending-admission'),
+      resolveHandlers: () => handlers,
+      resolveContinuity: () => undefined,
+      beginOperation: async () => {
+        admissionEntered.resolve();
+        await releaseAdmission.promise;
+        return {
+          acquireResidency: () => ({ release() {} }),
+          seal() {},
+          finish() {
+            finishCalls += 1;
+          },
+        };
+      },
+      onTeardown: () => teardownObserved.resolve(),
     });
-    await withTimeout(admissionEntered.promise, 1_000, 'operation did not enter admission');
-    pair.clientTransport.socket.resetAndDestroy();
-    await withTimeout(
-      teardownObserved.promise,
-      1_000,
-      'connection did not tear down while admission was pending',
-    );
-    releaseAdmission.resolve();
-    await withTimeout(run, 1_000, 'connection did not settle after admission completed');
-    assert.equal(handlerCalls, 0);
-    assert.equal(finishCalls, 1);
-  } finally {
-    releaseAdmission.resolve();
-    pair.clientTransport.abort();
-    await Promise.allSettled([run, pair.close()]);
-  }
-});
+    const run = session.run();
+    try {
+      await writeProtocolFrame(pair.clientTransport, {
+        requestId: 'pending-request',
+        operation: 'turn.query',
+        input: { sessionId: 'session', turnId: 'turn' },
+      });
+      await withTimeout(admissionEntered.promise, 1_000, 'operation did not enter admission');
+      if (closure === 'reset') {
+        pair.clientTransport.socket.resetAndDestroy();
+        await withTimeout(
+          teardownObserved.promise,
+          1_000,
+          'connection did not tear down while admission was pending',
+        );
+      } else {
+        const readEnded = onceSocketEnd(pair.serverTransport.socket);
+        pair.clientTransport.socket.end();
+        await withTimeout(readEnded, 1_000, 'Host did not observe EOF during admission');
+      }
+      releaseAdmission.resolve();
+      if (closure === 'eof') {
+        const response = decodeHostFrame(await pair.clientTransport.read(1_000));
+        assert.ok(!('kind' in response) && response.ok);
+      }
+      await withTimeout(run, 1_000, 'connection did not settle after admission completed');
+      assert.equal(handlerCalls, closure === 'reset' ? 0 : 1);
+      assert.equal(finishCalls, 1);
+    } finally {
+      releaseAdmission.resolve();
+      pair.clientTransport.abort();
+      await Promise.allSettled([run, pair.close()]);
+    }
+  });
+}
 
 test('a ready composition attaches the authenticated Client identity once', async () => {
   const pair = await openTransportPair();
diff --git a/packages/runtime-host/src/__tests__/execution-composition.test.ts b/packages/runtime-host/src/__tests__/execution-composition.test.ts
index 4c7cc83f84..c1b35a1960 100644
--- a/packages/runtime-host/src/__tests__/execution-composition.test.ts
+++ b/packages/runtime-host/src/__tests__/execution-composition.test.ts
@@ -19,6 +19,10 @@
 
 import assert from 'node:assert/strict';
 import { runtimeInvocationOutcome } from '@maka/core/runtime-invocation';
+import type { BackendSendInput } from '@maka/core/backend-types';
+import type { SessionEvent } from '@maka/core/events';
+import { runtimeHandoffPause } from '@maka/core/runtime-handoff';
+import { deferred } from '@maka/core/test-only/async-primitives';
 import { runtimeInvocationFailureClass } from '@maka/runtime/runtime-event-read-model';
 import { parseNoRealConnectionError } from '@maka/core/connection-error-copy';
 import { createRequire } from 'node:module';
@@ -38,7 +42,7 @@ import {
   FakeBackend,
 } from '@maka/runtime/test-only/fake-backend';
 import { LOCAL_READ_AGENT_DEFINITION } from '@maka/runtime/agent-catalog';
-import { SessionManager } from '@maka/runtime/session-manager';
+import { SessionManager, type BackendFactory } from '@maka/runtime/session-manager';
 import { workHubDirectStopAbortSource } from '@maka/runtime/session-manager';
 import { fingerprintAgentGraphRunnableIntent } from '@maka/runtime/stream-graph-admission';
 import type { AgentGraphRunnableIntent } from '@maka/runtime/stream-graph-readiness';
@@ -70,6 +74,125 @@ const require = createRequire(import.meta.url);
 const FAKE_CONNECTION_ID = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
 const CONTEXT_OFFLOAD_DATABASE_NAME = 'context-offload.sqlite';
 
+test('production composition resumes a sealed logical Root after all stores and runtime owners reopen', {
+  timeout: 20_000,
+}, async () => {
+  await withCompositionRoot(async ({ root, owner }) => {
+    const entered = deferred<void>();
+    const boundary = deferred<void>();
+    const requested = deferred<void>();
+    let dispatches = 0;
+    const backendFactory: BackendFactory = (context) =>
+      new (class extends FakeBackend {
+        override async *send(input: BackendSendInput): AsyncIterable<SessionEvent> {
+          dispatches += 1;
+          if (!input.continuation) {
+            assert.equal(input.maxSteps, 4);
+            entered.resolve();
+            await boundary.promise;
+            assert.equal(await input.handoffBoundary!(new AbortController().signal, 3), 'pause');
+            return;
+          }
+          assert.equal(input.maxSteps, 3);
+          yield {
+            type: 'complete',
+            id: 'completed-after-reopen',
+            turnId: input.turnId,
+            ts: Date.now(),
+            stopReason: 'end_turn',
+          };
+        }
+      })(context);
+    const residencies = new HostResidencyRegistry();
+    const first = await createCapturedExecutionComposition(owner, { primaryBackendFactory: backendFactory, residencies });
+    let successorOwner: InteractiveRootOwner | undefined;
+    let successor: Awaited<ReturnType<typeof createCapturedExecutionComposition>> | undefined;
+    try {
+      const request = first.manager.requestRunHandoff.bind(first.manager);
+      first.manager.requestRunHandoff = (...args) => {
+        const result = request(...args);
+        requested.resolve();
+        return result;
+      };
+      const session = await first.manager.createSession({
+        cwd: root,
+        llmConnectionId: FAKE_CONNECTION_ID,
+        llmConnectionSlug: 'fake',
+        model: 'fake-model',
+        permissionMode: 'ask',
+      });
+      const started = await first.composition.handlers['turn.start'](
+        {
+          sessionId: session.id,
+          turnId: 'reopen-handoff-turn',
+          content: { text: 'continue after restart' },
+          maxSteps: 4,
+        },
+        {
+          hostEpoch: 'execution-composition-test',
+          connectionId: 'client',
+          principal: 'local_os_user',
+          acquireResidency: () => residencies.acquire('test-operation'),
+        },
+      );
+      assert.equal(started.ok, true, JSON.stringify(started));
+      await entered.promise;
+      assert.ok(first.composition.prepareHandoff);
+      const preparing = first.composition.prepareHandoff(
+        'execution-composition-test',
+        new AbortController().signal,
+      );
+      await requested.promise;
+      boundary.resolve();
+      const preparation = await preparing;
+      assert.ok(preparation);
+      assert.equal(await preparation.seal(), true);
+      const transferred = await preparation.residencies();
+      assert.ok(transferred);
+      assert.equal(
+        residencies.hasDrainResidenciesExcept(transferred),
+        false,
+        JSON.stringify(residencies.snapshot()),
+      );
+      await preparation.detach();
+      first.composition.beginDrain();
+      await first.composition.close();
+      assert.equal(dispatches, 1);
+      await owner.close();
+
+      successorOwner = await tryAcquireInteractiveRootOwner(
+        await resolveStorageRoot({ path: root, kind: 'interactive' }),
+      );
+      assert.ok(successorOwner);
+      successor = await createCapturedExecutionComposition(successorOwner, { primaryBackendFactory: backendFactory });
+      const stores = await openInteractiveExecutionStoresForWrite(successorOwner.lease);
+      await waitFor(
+        async () =>
+          (await stores.runtimeEventStore.listSessionInvocations(session.id)).some(
+            (run) => runtimeInvocationOutcome(run) === 'completed',
+          ),
+        5_000,
+      );
+      const runs = await stores.runtimeEventStore.listSessionInvocations(session.id);
+      assert.equal(runs.length, 2);
+      assert.equal(new Set(runs.map((run) => run.turnId)).size, 1);
+      assert.equal(
+        runs.filter((run) => run.terminalEvent && runtimeHandoffPause(run.terminalEvent)).length,
+        1,
+      );
+      assert.equal(runs.filter((run) => runtimeInvocationOutcome(run) === 'completed').length, 1);
+      assert.equal(dispatches, 2);
+    } finally {
+      boundary.resolve();
+      first.composition.beginDrain();
+      await first.composition.close();
+      successor?.composition.beginDrain();
+      await successor?.composition.close();
+      await successorOwner?.close();
+    }
+  });
+});
+
 test('filesystem worker follows the candidate executable runtime', () => {
   assert.equal(runtimeHostFilesystemWorkerRuntime({ electron: '43.1.1' }), 'electron');
   assert.equal(runtimeHostFilesystemWorkerRuntime({}), 'node');
@@ -1863,13 +1986,19 @@ async function seedLegacyFakeBackendSession(
 
 async function createCapturedExecutionComposition(
   owner: InteractiveRootOwner,
-  options: { readonly safeBoundaryResume?: boolean } = {},
+  options: {
+    readonly safeBoundaryResume?: boolean;
+    readonly primaryBackendFactory?: BackendFactory;
+    readonly residencies?: HostResidencyRegistry;
+  } = {},
 ): Promise<{
   composition: Awaited<ReturnType<typeof createExecutionRuntimeHostComposition>>;
   manager: SessionManager;
 }> {
   const originalRecover = SessionManager.prototype.recoverInterruptedSessionsStrict;
   const originalSafeBoundaryResume = process.env.MAKA_RUNTIME_SAFE_BOUNDARY_RESUME;
+  const primaryBackendFactory = options.primaryBackendFactory ?? ((context) => new FakeBackend(context));
+  const residencies = options.residencies;
   let manager: SessionManager | undefined;
   SessionManager.prototype.recoverInterruptedSessionsStrict = async function (stores) {
     manager = this;
@@ -1882,9 +2011,12 @@ async function createCapturedExecutionComposition(
     // own; the deterministic one arrives through the same `primaryBackendFactory`
     // seam the Desktop E2E run uses.
     const composition = await createExecutionRuntimeHostComposition(
-      compositionContext(owner),
+      {
+        ...compositionContext(owner),
+        ...(residencies ? { acquireResidency: (label: string) => residencies.acquire(label) } : {}),
+      },
       {},
-      { primaryBackendFactory: (backendContext) => new FakeBackend(backendContext) },
+      { primaryBackendFactory },
     );
     await composition.recover();
     if (!manager) throw new Error('Production execution composition did not construct Runtime');
diff --git a/packages/runtime-host/src/__tests__/goal-root-authority.test.ts b/packages/runtime-host/src/__tests__/goal-root-authority.test.ts
index abd2ddd8e5..85094cc634 100644
--- a/packages/runtime-host/src/__tests__/goal-root-authority.test.ts
+++ b/packages/runtime-host/src/__tests__/goal-root-authority.test.ts
@@ -575,6 +575,7 @@ async function createFixture(options: { recoverAdmissions?: boolean } = {}): Pro
     hostEpoch,
     root: rootPort,
     durableProof: {
+      readLogicalExecution: async () => undefined,
       readRootTurnSourceMessageReceipt: (sessionId, messageId) =>
         stores.agentRunStore.readRootTurnSourceMessageReceipt(sessionId, messageId),
       readImmutableSteeringMessageProof: (sessionId, messageId) =>
diff --git a/packages/runtime-host/src/__tests__/host-handoff.test.ts b/packages/runtime-host/src/__tests__/host-handoff.test.ts
new file mode 100644
index 0000000000..3ebe8ebb0b
--- /dev/null
+++ b/packages/runtime-host/src/__tests__/host-handoff.test.ts
@@ -0,0 +1,504 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { deferred } from '@maka/core/test-only/async-primitives';
+import {
+  HostHandoffCancelledError,
+  HostHandoffRequiredError,
+  runHostHandoff,
+  type HostHandoffAction,
+  type HostHandoffBlocker,
+  type HostHandoffView,
+  type OpenHostHandoffSurface,
+} from '../client/host-handoff.js';
+import { decodeClientFrame, decodeHostFrame } from '../protocol/index.js';
+import { decodeHostActivitySnapshot, isHostActivityIdle } from '../protocol/host-status.js';
+
+const idle = { connections: 0, activeOperations: 0, processUptimeSeconds: 1, residencies: [] };
+const target = {
+  name: 'Local workspace',
+  location: 'local' as const,
+  rootId: 'root',
+  hostEpoch: 'a',
+};
+const resource = <T>(value: T) => ({ value, async close() {} });
+const blocked = (blocker: HostHandoffBlocker) => ({ kind: 'blocked' as const, blocker });
+const base: HostHandoffBlocker = {
+  identity: 'root/owner/a',
+  target,
+  reason: 'upgrade',
+  mayExitNaturally: false,
+};
+
+function surfaceHarness() {
+  let submit: (revision: string, action: HostHandoffAction) => void;
+  let latest: HostHandoffView | undefined;
+  let closed = false;
+  const waiters = new Set<{
+    predicate(view: HostHandoffView): boolean;
+    resolve(view: HostHandoffView): void;
+  }>();
+  const openSurface: OpenHostHandoffSurface = (callback) => {
+    submit = callback;
+    return {
+      update(view) {
+        latest = view;
+        for (const waiter of waiters)
+          if (waiter.predicate(view)) {
+            waiters.delete(waiter);
+            waiter.resolve(view);
+          }
+      },
+      close() {
+        closed = true;
+      },
+    };
+  };
+  return {
+    openSurface,
+    get closed() {
+      return closed;
+    },
+    choose(view: HostHandoffView, action: HostHandoffAction) {
+      submit(view.revision, action);
+    },
+    view(predicate: (view: HostHandoffView) => boolean = () => true): Promise<HostHandoffView> {
+      if (latest && predicate(latest)) return Promise.resolve(latest);
+      return new Promise((resolve) => waiters.add({ predicate, resolve }));
+    },
+  };
+}
+
+test('compatible connection needs no handoff surface', async () => {
+  assert.equal(
+    (await runHostHandoff({ observe: async () => ({ kind: 'ready', value: resource(42) }) })).value,
+    42,
+  );
+});
+
+test('maintenance evidence distinguishes idle retention without guessing for legacy activity', () => {
+  const retention = { ...idle, residencies: [{ label: 'process-retention', count: 1 }] };
+  assert.equal(isHostActivityIdle(decodeHostActivitySnapshot(retention)), false);
+  assert.equal(
+    isHostActivityIdle(decodeHostActivitySnapshot({ ...retention, drainResidencies: 0 })),
+    true,
+  );
+  assert.equal(isHostActivityIdle({ ...retention, drainResidencies: 1 }), false);
+  assert.throws(() => decodeHostActivitySnapshot({ ...retention, drainResidencies: -1 }));
+  assert.throws(() => decodeHostActivitySnapshot({ ...retention, drainResidencies: '0' }));
+});
+
+test('activity extension is opt-in and old handshake activity remains decodable', () => {
+  const hello = {
+    kind: 'hello',
+    clientInstanceId: 'client',
+    protocolMin: 0,
+    protocolMax: 0,
+    compatibilityEpoch: 119,
+    compositionId: 'interactive',
+  };
+  assert.deepEqual(decodeClientFrame(hello), hello);
+  assert.deepEqual(decodeClientFrame({ ...hello, activitySnapshotVersion: 2 }), {
+    ...hello,
+    activitySnapshotVersion: 2,
+  });
+  const legacy = {
+    kind: 'incompatible',
+    hostEpoch: 'host',
+    protocolMin: 0,
+    protocolMax: 0,
+    compatibilityEpoch: 50,
+    compositionId: 'interactive',
+    compositionRevision: 'legacy',
+    state: 'ready',
+    replacement: 'blocked_by_residency',
+    activity: idle,
+  };
+  assert.deepEqual(decodeHostFrame(legacy), legacy);
+});
+
+test('verified idle replacement is automatic but readiness must be reobserved', async () => {
+  let ready = false;
+  assert.equal(
+    (
+      await runHostHandoff({
+        observe: async () =>
+          ready
+            ? { kind: 'ready', value: resource('successor') }
+            : blocked({
+                ...base,
+                activity: idle,
+                replacement: {
+                  kind: 'replace',
+                  canReplaceIdle: true,
+                  canInterrupt: true,
+                  async execute(policy) {
+                    assert.equal(policy, 'refuse_active_work');
+                    ready = true;
+                    return { kind: 'completed' };
+                  },
+                },
+              }),
+      })
+    ).value,
+    'successor',
+  );
+});
+
+test('negotiated cooperative work can continue automatically without interruption consent', async () => {
+  let ready = false;
+  const result = await runHostHandoff({
+    observe: async () =>
+      ready
+        ? { kind: 'ready', value: resource('continued') }
+        : blocked({
+            ...base,
+            activity: {
+              ...idle,
+              cooperativeHandoff: true,
+              drainResidencies: 1,
+              residencies: [{ label: 'hosted-execution', count: 1 }],
+            },
+            replacement: {
+              kind: 'replace',
+              canReplaceIdle: true,
+              canInterrupt: false,
+              async execute(policy, _progress, consent) {
+                assert.equal(policy, 'refuse_active_work');
+                assert.equal(consent, 'automatic');
+                ready = true;
+                return { kind: 'completed' };
+              },
+            },
+          }),
+  });
+  assert.equal(result.value, 'continued');
+});
+
+test('progress Cancel aborts cooperative convergence but awaits safe transaction settlement', async () => {
+  const ui = surfaceHarness();
+  const aborted = deferred<void>();
+  const release = deferred<void>();
+  let finished = false;
+  const running = runHostHandoff({
+    openSurface: ui.openSurface,
+    observe: async () =>
+      blocked({
+        ...base,
+        activity: {
+          ...idle,
+          cooperativeHandoff: true,
+          drainResidencies: 1,
+          residencies: [{ label: 'hosted-execution', count: 1 }],
+        },
+        replacement: {
+          kind: 'replace',
+          canReplaceIdle: true,
+          canInterrupt: false,
+          async execute(_policy, _progress, _consent, signal) {
+            assert.ok(signal);
+            signal.addEventListener('abort', () => aborted.resolve(), { once: true });
+            await release.promise;
+            return { kind: 'active_work' };
+          },
+        },
+      }),
+  });
+  const rejection = assert.rejects(running, HostHandoffCancelledError).then(() => {
+    finished = true;
+  });
+  const view = await ui.view((candidate) => candidate.state === 'progress');
+  assert.equal(view.phase, 'pausing');
+  assert.deepEqual(view.actions, ['cancel']);
+  ui.choose(view, 'cancel');
+  await aborted.promise;
+  assert.equal(finished, false);
+  assert.equal(ui.closed, false);
+  release.resolve();
+  await rejection;
+  assert.equal(ui.closed, true);
+});
+
+test('unknown work requires explicit non-default consent', async () => {
+  const ui = surfaceHarness();
+  let ready = false;
+  const running = runHostHandoff({
+    openSurface: ui.openSurface,
+    pollIntervalMs: 1,
+    observe: async () =>
+      ready
+        ? { kind: 'ready', value: resource('done') }
+        : blocked({
+            ...base,
+            replacement: {
+              kind: 'replace',
+              canReplaceIdle: false,
+              canInterrupt: true,
+              async execute(policy) {
+                assert.equal(policy, 'interrupt_active_work');
+                ready = true;
+                return { kind: 'completed' };
+              },
+            },
+          }),
+  });
+  const view = await ui.view();
+  assert.equal(view.reason, 'activity_unknown');
+  assert.equal(view.defaultAction, 'cancel');
+  ui.choose(view, 'interrupt');
+  assert.equal((await running).value, 'done');
+  assert.equal(ui.closed, true);
+});
+
+test('cancel during observation wins over a changed idle successor', async () => {
+  const ui = surfaceHarness();
+  let markObserving!: () => void;
+  let releaseObservation!: () => void;
+  const observing = new Promise<void>((resolve) => {
+    markObserving = resolve;
+  });
+  const release = new Promise<void>((resolve) => {
+    releaseObservation = resolve;
+  });
+  let observations = 0;
+  const running = runHostHandoff({
+    openSurface: ui.openSurface,
+    pollIntervalMs: 1,
+    observe: async () => {
+      if (observations++ === 0) return blocked(base);
+      markObserving();
+      await release;
+      return blocked({
+        ...base,
+        identity: 'successor',
+        activity: idle,
+        replacement: {
+          kind: 'replace',
+          canReplaceIdle: true,
+          canInterrupt: true,
+          async execute() {
+            assert.fail('Cancel must not start replacement');
+          },
+        },
+      });
+    },
+  });
+  const view = await ui.view();
+  await observing;
+  ui.choose(view, 'cancel');
+  releaseObservation();
+  await assert.rejects(running, HostHandoffCancelledError);
+  assert.equal(ui.closed, true);
+});
+
+test('fresh observation invalidates consent when the Host changes before a click is applied', async () => {
+  const ui = surfaceHarness();
+  let epoch = 'a';
+  const running = runHostHandoff({
+    openSurface: ui.openSurface,
+    pollIntervalMs: 1,
+    observe: async () =>
+      blocked({
+        ...base,
+        identity: epoch,
+        target: { ...target, hostEpoch: epoch },
+        replacement: {
+          kind: 'replace',
+          canReplaceIdle: false,
+          canInterrupt: true,
+          async execute() {
+            assert.fail('Stale consent must never invoke replacement');
+          },
+        },
+      }),
+  });
+  const old = await ui.view();
+  epoch = 'b';
+  ui.choose(old, 'interrupt');
+  const current = await ui.view((view) => view.target.hostEpoch === 'b');
+  assert.notEqual(current.revision, old.revision);
+  ui.choose(old, 'interrupt');
+  ui.choose(current, 'cancel');
+  await assert.rejects(running, HostHandoffCancelledError);
+});
+
+test('a live blocking surface resolves automatically when work finishes', async () => {
+  const ui = surfaceHarness();
+  let active = true;
+  let ready = false;
+  const running = runHostHandoff({
+    openSurface: ui.openSurface,
+    pollIntervalMs: 1,
+    observe: async () =>
+      ready
+        ? { kind: 'ready', value: resource('done') }
+        : blocked({
+            ...base,
+            activity: { ...idle, activeOperations: active ? 1 : 0 },
+            replacement: {
+              kind: 'replace',
+              canReplaceIdle: true,
+              canInterrupt: true,
+              async execute(policy) {
+                assert.equal(policy, 'refuse_active_work');
+                ready = true;
+                return { kind: 'completed' };
+              },
+            },
+          }),
+  });
+  assert.equal((await ui.view()).reason, 'busy');
+  active = false;
+  assert.equal((await running).value, 'done');
+  assert.equal(ui.closed, true);
+});
+
+test('automatic replacement attempts are bounded even if every successor conflicts', async () => {
+  let epoch = 0;
+  await assert.rejects(
+    runHostHandoff({
+      observe: async () =>
+        blocked({
+          ...base,
+          identity: String(epoch),
+          activity: idle,
+          replacement: {
+            kind: 'replace',
+            canReplaceIdle: true,
+            canInterrupt: true,
+            async execute() {
+              epoch += 1;
+              return { kind: 'completed' };
+            },
+          },
+        }),
+    }),
+    HostHandoffRequiredError,
+  );
+  assert.equal(epoch, 3);
+});
+
+test('an admission refusal does not repeatedly retry the same idle observation', async () => {
+  let replacements = 0;
+  await assert.rejects(
+    runHostHandoff({
+      observe: async () =>
+        blocked({
+          ...base,
+          activity: idle,
+          replacement: {
+            kind: 'replace',
+            canReplaceIdle: true,
+            canInterrupt: true,
+            async execute() {
+              replacements += 1;
+              return { kind: 'active_work' };
+            },
+          },
+        }),
+    }),
+    HostHandoffRequiredError,
+  );
+  assert.equal(replacements, 1);
+});
+
+test('remote operators get actionable retry without local interruption authority', async () => {
+  await assert.rejects(
+    runHostHandoff({
+      observe: async () =>
+        blocked({
+          ...base,
+          target: { ...target, location: 'remote' },
+          operatorStep: 'Update Maka on office-mac, then retry.',
+        }),
+    }),
+    (error: unknown) => {
+      assert.ok(error instanceof HostHandoffRequiredError);
+      assert.deepEqual(error.view.actions, ['cancel', 'retry']);
+      assert.equal(error.view.operatorStep, 'Update Maka on office-mac, then retry.');
+      return true;
+    },
+  );
+});
+
+test('transaction failure remains a repair outcome instead of an automatic retry loop', async () => {
+  await assert.rejects(
+    runHostHandoff({
+      observe: async () =>
+        blocked({
+          ...base,
+          activity: idle,
+          replacement: {
+            kind: 'repair',
+            canReplaceIdle: true,
+            canInterrupt: true,
+            async execute() {
+              return { kind: 'recovery_required', diagnostic: 'Writer release was not verified' };
+            },
+          },
+        }),
+    }),
+    (error: unknown) => {
+      assert.ok(error instanceof HostHandoffRequiredError);
+      assert.equal(error.view.reason, 'repair_required');
+      assert.equal(error.view.diagnostic, 'Writer release was not verified');
+      return true;
+    },
+  );
+});
+
+test('cancellation does not abandon an in-flight deployment transaction', async () => {
+  const abort = new AbortController();
+  let markStarted!: () => void;
+  let markFinished!: () => void;
+  const started = new Promise<void>((resolve) => {
+    markStarted = resolve;
+  });
+  const finish = new Promise<void>((resolve) => {
+    markFinished = resolve;
+  });
+  let settled = false;
+  const running = runHostHandoff({
+    signal: abort.signal,
+    observe: async () =>
+      blocked({
+        ...base,
+        activity: idle,
+        replacement: {
+          kind: 'replace',
+          canReplaceIdle: true,
+          canInterrupt: true,
+          async execute() {
+            markStarted();
+            await finish;
+            settled = true;
+            return { kind: 'completed' };
+          },
+        },
+      }),
+  });
+  await started;
+  abort.abort(new Error('cancelled'));
+  assert.equal(settled, false);
+  markFinished();
+  await assert.rejects(running, /cancelled/);
+  assert.equal(settled, true);
+});
diff --git a/packages/runtime-host/src/__tests__/host-kernel.test.ts b/packages/runtime-host/src/__tests__/host-kernel.test.ts
index 2c25043b0a..4967ebfe78 100644
--- a/packages/runtime-host/src/__tests__/host-kernel.test.ts
+++ b/packages/runtime-host/src/__tests__/host-kernel.test.ts
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-import { withTimeout } from '@maka/core/test-only/async-primitives';
+import { deferred, withTimeout } from '@maka/core/test-only/async-primitives';
 import { RuntimeHostProtocolError } from '../protocol/errors.js';
 import { defineInteractiveRuntimeHostComposition } from '../server/host-composition.js';
 import assert from 'node:assert/strict';
@@ -1036,6 +1036,130 @@ describe('non-serving Runtime Host kernel', () => {
     });
   });
 
+  for (const scenario of ['transfer', 'unproven_residency', 'seal_refused'] as const) {
+    test(`cooperative Host handoff ${scenario} requires exact residency proof`, async () => {
+      await withHostPaths(async (paths) => {
+        const capability = await resolveStorageRoot({ path: paths.root, kind: 'interactive' });
+        const owner = await tryAcquireInteractiveRootOwner(capability);
+        assert.ok(owner);
+        let detached = 0;
+        let cancelled = 0;
+        let release = () => {};
+        const host = await RuntimeHostKernel.start({
+          owner,
+          lifecycleMode: 'service',
+          composition: defineInteractiveRuntimeHostComposition(async (context) => {
+            const proven = context.acquireResidency('hosted-execution');
+            const unknown =
+              scenario === 'unproven_residency'
+                ? context.acquireResidency('hosted-execution')
+                : undefined;
+            release = () => {
+              proven.release();
+              unknown?.release();
+            };
+            return {
+              ...testComposition(),
+              prepareHandoff: async () => ({
+                seal: async () => scenario !== 'seal_refused',
+                residencies: async () => [proven],
+                detach: async () => {
+                  detached += 1;
+                  proven.release();
+                },
+                cancel: () => {
+                  cancelled += 1;
+                },
+              }),
+            };
+          }),
+        });
+        const connected = await retryConnect(paths, CURRENT_PROTOCOL);
+        assert.equal(connected.kind, 'connected');
+        if (connected.kind !== 'connected') return;
+        try {
+          const result = await connected.connection.request('host.upgrade.prepare', {
+            expectedHostEpoch: host.hostEpoch,
+            allowInterruptActiveTasks: false,
+            allowCooperativeHandoff: true,
+          });
+          assert.equal(result.kind, scenario === 'transfer' ? 'prepared' : 'active_tasks');
+          assert.equal(detached, scenario === 'transfer' ? 1 : 0);
+          assert.equal(cancelled, scenario === 'transfer' ? 0 : 1);
+          if (scenario !== 'transfer') {
+            assert.equal(host.state, 'ready');
+            assert.equal((await connected.connection.status()).state, 'ready');
+          }
+        } finally {
+          release();
+          await connected.connection.close();
+          await host.close();
+        }
+      });
+    });
+  }
+
+  test('disconnect while converging cancels handoff and reopens command admission', async () => {
+    await withHostPaths(async (paths) => {
+      const owner = await tryAcquireInteractiveRootOwner(
+        await resolveStorageRoot({ path: paths.root, kind: 'interactive' }),
+      );
+      assert.ok(owner);
+      const preparing = deferred<void>();
+      const cancelled = deferred<void>();
+      let release = () => {};
+      const host = await RuntimeHostKernel.start({
+        owner,
+        lifecycleMode: 'service',
+        composition: defineInteractiveRuntimeHostComposition(async (context) => {
+          const residency = context.acquireResidency('hosted-execution');
+          release = residency.release;
+          return {
+            ...testComposition(),
+            prepareHandoff: async (_epoch, signal) => {
+              preparing.resolve();
+              await new Promise<void>((resolve) =>
+                signal.addEventListener(
+                  'abort',
+                  () => {
+                    cancelled.resolve();
+                    resolve();
+                  },
+                  { once: true },
+                ),
+              );
+              return undefined;
+            },
+          };
+        }),
+      });
+      const connected = await retryConnect(paths, CURRENT_PROTOCOL);
+      assert.equal(connected.kind, 'connected');
+      if (connected.kind !== 'connected') return;
+      try {
+        const request = connected.connection
+          .request('host.upgrade.prepare', {
+            expectedHostEpoch: host.hostEpoch,
+            allowInterruptActiveTasks: false,
+            allowCooperativeHandoff: true,
+          })
+          .catch(() => undefined);
+        await withTimeout(preparing.promise, 2_000, 'Handoff did not begin');
+        await connected.connection.close();
+        await withTimeout(cancelled.promise, 2_000, 'Disconnect did not cancel handoff');
+        await request;
+        assert.equal(host.state, 'ready');
+        const retry = await retryConnect(paths, CURRENT_PROTOCOL);
+        assert.equal(retry.kind, 'connected');
+        if (retry.kind === 'connected') await retry.connection.close();
+      } finally {
+        release();
+        await connected.connection.close();
+        await host.close();
+      }
+    });
+  });
+
   test('local owner can prepare a managed service Host for retirement', async () => {
     await withHostPaths(async (paths) => {
       const capability = await resolveStorageRoot({ path: paths.root, kind: 'interactive' });
@@ -1198,6 +1322,49 @@ describe('non-serving Runtime Host kernel', () => {
     });
   });
 
+  test('idle process retention permits a fenced handoff but never claims natural exit', async () => {
+    await withHostPaths(async (paths) => {
+      const capability = await resolveStorageRoot({ path: paths.root, kind: 'interactive' });
+      const owner = await tryAcquireInteractiveRootOwner(capability);
+      assert.ok(owner);
+      const host = await RuntimeHostKernel.start({
+        owner,
+        generation: 'desktop-old',
+        idleGraceMs: 10_000,
+        composition: defineInteractiveRuntimeHostComposition(async (context) => {
+          context.retainUntilProcessExit();
+          return testComposition();
+        }),
+      });
+      try {
+        const observed = await connectRuntimeHost({
+          rootPath: paths.root,
+          protocol: CURRENT_PROTOCOL,
+          generation: 'desktop-new',
+        });
+        assert.equal(observed.kind, 'upgrade_required');
+        if (observed.kind !== 'upgrade_required') return;
+        assert.equal(observed.restartable, true);
+        assert.equal(observed.handshake?.replacement, 'blocked_by_residency');
+        assert.equal(observed.handshake?.activity?.drainResidencies, 0);
+        assert.deepEqual(observed.handshake?.activity?.residencies, [
+          { label: 'process-retention', count: 1 },
+        ]);
+        const replaced = await connectRuntimeHost({
+          rootPath: paths.root,
+          protocol: CURRENT_PROTOCOL,
+          generation: 'desktop-new',
+          takeoverHostEpoch: host.hostEpoch,
+        });
+        assert.equal(replaced.kind, 'draining');
+        await host.closed;
+        assert.equal(host.shutdownReason, 'retirement');
+      } finally {
+        await host.close();
+      }
+    });
+  });
+
   test('does not take over an idle-looking Host with a residency acquired after discovery', async () => {
     await withHostPaths(async (paths) => {
       let context: RuntimeHostCompositionContext | undefined;
diff --git a/packages/runtime-host/src/__tests__/host-retirement.test.ts b/packages/runtime-host/src/__tests__/host-retirement.test.ts
index 890aad0359..adf9063771 100644
--- a/packages/runtime-host/src/__tests__/host-retirement.test.ts
+++ b/packages/runtime-host/src/__tests__/host-retirement.test.ts
@@ -34,6 +34,10 @@ test('retirement binds both interruption policy choices to the authenticated Hos
 
   await prepareConnectedRuntimeHostRetirement(connection, 'refuse_active_work');
   await prepareConnectedRuntimeHostRetirement(connection, 'interrupt_active_work');
+  await prepareConnectedRuntimeHostRetirement(
+    { ...connection, cooperativeHandoff: true },
+    'refuse_active_work',
+  );
 
   assert.deepEqual(requests, [
     {
@@ -50,5 +54,46 @@ test('retirement binds both interruption policy choices to the authenticated Hos
         allowInterruptActiveTasks: true,
       },
     },
+    {
+      operation: 'host.upgrade.prepare',
+      input: {
+        expectedHostEpoch: 'authenticated-host',
+        allowInterruptActiveTasks: false,
+        allowCooperativeHandoff: true,
+      },
+    },
   ]);
 });
+
+test('cancelling preparation closes its connection and waits for the request to settle', async () => {
+  const cancellation = new AbortController();
+  let rejectRequest!: (error: Error) => void;
+  let closed = false;
+  let settled = false;
+  const connection = {
+    hostEpoch: 'source',
+    cooperativeHandoff: true,
+    request: () =>
+      new Promise((_resolve, reject) => {
+        rejectRequest = reject;
+      }),
+    close: async () => {
+      closed = true;
+    },
+  } as unknown as RuntimeHostConnection;
+  const result = prepareConnectedRuntimeHostRetirement(
+    connection,
+    'refuse_active_work',
+    undefined,
+    cancellation.signal,
+  );
+  const rejected = assert.rejects(result, /user cancelled/u).then(() => {
+    settled = true;
+  });
+  cancellation.abort(new Error('user cancelled'));
+  await Promise.resolve();
+  assert.equal(closed, true);
+  assert.equal(settled, false);
+  rejectRequest(new Error('connection closed'));
+  await rejected;
+});
diff --git a/packages/runtime-host/src/__tests__/message-coordinator.test.ts b/packages/runtime-host/src/__tests__/message-coordinator.test.ts
index 190bdeb598..f01c55c040 100644
--- a/packages/runtime-host/src/__tests__/message-coordinator.test.ts
+++ b/packages/runtime-host/src/__tests__/message-coordinator.test.ts
@@ -3808,6 +3808,7 @@ function createFixture(
     hostEpoch: 'epoch-1',
     root,
     durableProof: {
+      readLogicalExecution: async () => undefined,
       readRootTurnSourceMessageReceipt: async (_sessionId, messageId) => receipts.get(messageId),
       readImmutableSteeringMessageProof: async (_sessionId, messageId) => {
         const event = events.find(
diff --git a/packages/runtime-host/src/__tests__/root-turn-coordinator.test.ts b/packages/runtime-host/src/__tests__/root-turn-coordinator.test.ts
index d2c5e1e8c6..a4f3b26ffc 100644
--- a/packages/runtime-host/src/__tests__/root-turn-coordinator.test.ts
+++ b/packages/runtime-host/src/__tests__/root-turn-coordinator.test.ts
@@ -21,8 +21,13 @@ import { deferred, withTimeout } from '@maka/core/test-only/async-primitives';
 import assert from 'node:assert/strict';
 import { readInvocation, seedInvocation } from '@maka/runtime/test-only/invocation-fixture';
 import { runtimeInvocationOutcome } from '@maka/core/runtime-invocation';
+import {
+  readLogicalRuntimeExecution,
+  readLogicalRuntimeExecutionForRun,
+} from '@maka/core/runtime-logical-execution';
 import { runtimeInvocationFailureClass } from '@maka/runtime/runtime-event-read-model';
 import { randomUUID } from 'node:crypto';
+import { createSessionTranscriptReader } from '../server/session-transcript-reader.js';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
@@ -2676,6 +2681,8 @@ test('hosted linked child roots share admission, message, terminal, and stop aut
       hostEpoch,
       root: rootPort,
       durableProof: {
+        readLogicalExecution: (identity) =>
+          readLogicalRuntimeExecutionForRun(stores.runtimeEventStore, identity),
         readRootTurnSourceMessageReceipt: (sessionId, messageId) =>
           stores.agentRunStore.readRootTurnSourceMessageReceipt(sessionId, messageId),
         readImmutableSteeringMessageProof: (sessionId, messageId) =>
@@ -5138,8 +5145,393 @@ async function registerSessionCapability(
   assert.equal(replaced.ok, true);
 }
 
+for (const stopAfterSeal of [false, true]) {
+  test(`physical handoff ${stopAfterSeal ? 'Stop after seal' : 'completion'} keeps the original Root admission`, {
+    timeout: 10_000,
+  }, async () => {
+    const entered = deferred<void>();
+    const boundary = deferred<void>();
+    const sealPersisted = deferred<void>();
+    const releaseSeal = deferred<void>();
+    let dispatches = 0;
+    const fixture = await createFailureFixture({
+      continuationSafety: { workspaceIdentity: 'handoff-workspace', availableToolNames: [] },
+      withInteractions: true,
+      ...(stopAfterSeal
+        ? {
+            afterHandoffSeal: async () => {
+              sealPersisted.resolve();
+              await releaseSeal.promise;
+            },
+          }
+        : {}),
+      registerBackend: (backends) =>
+        backends.register(
+          'ai-sdk',
+          (context) =>
+            new (class extends FakeBackend {
+              override async *send(input: BackendSendInput): AsyncIterable<SessionEvent> {
+                dispatches += 1;
+                if (!input.continuation) {
+                  entered.resolve();
+                  await boundary.promise;
+                  if ((await input.handoffBoundary!(new AbortController().signal, 2)) === 'pause')
+                    return;
+                } else assert.equal(input.maxSteps, 2);
+                yield {
+                  type: 'complete',
+                  id: randomUUID(),
+                  turnId: input.turnId,
+                  ts: Date.now(),
+                  stopReason: 'end_turn',
+                };
+              }
+            })(context),
+        ),
+    });
+    try {
+      const started = await fixture.interactiveTurns.handlers['turn.start'](
+        {
+          sessionId: fixture.sessionId,
+          turnId: 'handoff-turn',
+          content: { text: 'continue work' },
+        },
+        operationContext(fixture.hostEpoch, fixture.acquireResidency),
+      );
+      assertStartedTurn(started);
+      if (!started.ok) throw new Error('Expected started Turn');
+      await entered.promise;
+      const rootRunId = started.result.turn.runId;
+      const request = fixture.manager.requestRunHandoff(
+        fixture.sessionId,
+        rootRunId,
+        {
+          protocol: 'runtime_handoff_pause_v1',
+          handoffId: 'handoff',
+          hostEpoch: fixture.hostEpoch,
+          rootRunId,
+          successorRunId: 'successor-run',
+          successorInvocationId: 'successor-run',
+          claimId: 'handoff-claim',
+        },
+        new AbortController().signal,
+      );
+      assert.ok(request);
+      boundary.resolve();
+      assert.equal(await request.ready, true);
+      assert.equal(request.commit(), true);
+      let stopping: Promise<void> | undefined;
+      if (stopAfterSeal) {
+        await sealPersisted.promise;
+        stopping = fixture.coordinator.stopRoot({
+          sessionId: fixture.sessionId,
+          turnId: 'handoff-turn',
+          runId: rootRunId,
+        });
+        void stopping.catch(() => {});
+        await fixture.sessionAdmission.run(fixture.sessionId, () => {});
+        releaseSeal.resolve();
+      }
+      assert.equal(await request.sealed, true);
+      releaseSeal.resolve();
+      await stopping;
+      await fixture.coordinator.whenIdle(fixture.sessionId);
+      const logical = await readLogicalRuntimeExecution(fixture.stores.runtimeEventStore, {
+        sessionId: fixture.sessionId,
+        turnId: 'handoff-turn',
+        runId: rootRunId,
+      });
+      assert.equal(dispatches, stopAfterSeal ? 1 : 2);
+      assert.equal(logical?.tip.terminalEvent?.status, stopAfterSeal ? 'aborted' : 'completed');
+      assert.equal(logical?.tip.runId, 'successor-run');
+      assert.equal(
+        (
+          await fixture.stores.agentRunStore.readRootTurnAdmission(
+            fixture.sessionId,
+            'handoff-turn',
+          )
+        )?.runId,
+        rootRunId,
+      );
+      assert.equal(fixture.drainRequested(), false);
+    } finally {
+      boundary.resolve();
+      releaseSeal.resolve();
+      await fixture.coordinator.close();
+      await fixture.messages.close();
+      await fixture.dispose();
+    }
+  });
+}
+
+test('repeated handoffs preserve one logical admission, decreasing budget and exactly-once steering', {
+  timeout: 10_000,
+}, async () => {
+  const entered = Array.from({ length: 3 }, () => deferred<void>());
+  const release = Array.from({ length: 3 }, () => deferred<void>());
+  let dispatches = 0;
+  const injected: string[] = [];
+  const fixture = await createFailureFixture({
+    continuationSafety: { workspaceIdentity: 'handoff-workspace', availableToolNames: [] },
+    withInteractions: true,
+    registerBackend: (backends) =>
+      backends.register(
+        'ai-sdk',
+        (context) =>
+          new (class extends FakeBackend {
+            override async *send(input: BackendSendInput): AsyncIterable<SessionEvent> {
+              const attempt = dispatches++;
+              assert.ok(attempt < 3, 'handoff cannot create an extra logical turn');
+              assert.equal(input.maxSteps, 5 - attempt);
+              yield {
+                type: attempt === 2 ? 'text_delta' : 'text_complete',
+                id: randomUUID(),
+                turnId: input.turnId,
+                ts: Date.now(),
+                messageId: `assistant-${attempt}`,
+                text: `answer ${attempt}`,
+              };
+              entered[attempt]!.resolve();
+              await release[attempt]!.promise;
+              assert.ok(input.pullSteering, 'successors retain the logical message owner');
+              const leases = input.pullSteering();
+              assert.equal(leases.length, 1);
+              for (const lease of leases) {
+                yield {
+                  type: 'steering_message',
+                  id: randomUUID(),
+                  turnId: input.turnId,
+                  ts: Date.now(),
+                  messageId: lease.messageId,
+                  content: lease.content,
+                  ...(lease.submittedContentDigest
+                    ? { submittedContentDigest: lease.submittedContentDigest }
+                    : {}),
+                };
+                input.ackSteering?.([lease.id]);
+                injected.push(lease.messageId);
+              }
+              if (
+                attempt < 2 &&
+                (await input.handoffBoundary!(new AbortController().signal, 4 - attempt)) ===
+                  'pause'
+              )
+                return;
+              yield {
+                type: 'complete',
+                id: randomUUID(),
+                turnId: input.turnId,
+                ts: Date.now(),
+                stopReason: 'end_turn',
+              };
+            }
+          })(context),
+      ),
+  });
+  try {
+    const started = await fixture.interactiveTurns.handlers['turn.start'](
+      {
+        sessionId: fixture.sessionId,
+        turnId: 'repeated-handoff',
+        content: { text: 'continue' },
+        maxSteps: 5,
+      },
+      operationContext(fixture.hostEpoch, fixture.acquireResidency),
+    );
+    assertStartedTurn(started);
+    if (!started.ok) throw new Error('Expected started Turn');
+    const rootRunId = started.result.turn.runId;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      await entered[attempt]!.promise;
+      if (attempt === 2) {
+        const transcript = createSessionTranscriptReader({
+          stores: fixture.stores,
+          canonicalPermissionOutcomes: { readPermissionOutcome: async () => undefined },
+        });
+        const overlay = await transcript.readActiveOverlay(fixture.sessionId, {
+          sessionId: fixture.sessionId,
+          turnId: 'repeated-handoff',
+          runId: rootRunId,
+          status: 'running',
+        });
+        assert.deepEqual(
+          overlay.filter((message) => message.type === 'assistant').map((message) => message.id),
+          ['assistant-0', 'assistant-1', 'assistant-2'],
+        );
+      }
+      const submitted = await fixture.messages.handlers['turn.message.submit'](
+        {
+          originHostEpoch: fixture.hostEpoch,
+          sessionId: fixture.sessionId,
+          messageId: `steer-${attempt}`,
+          content: { text: `instruction ${attempt}` },
+          placement: 'current_turn',
+        },
+        operationContext(fixture.hostEpoch, fixture.acquireResidency),
+      );
+      assert.equal(submitted.ok && submitted.result.disposition, 'steering');
+      if (attempt < 2) {
+        const request = fixture.manager.requestRunHandoff(
+          fixture.sessionId,
+          attempt === 0 ? rootRunId : `successor-${attempt}`,
+          {
+            protocol: 'runtime_handoff_pause_v1',
+            handoffId: `handoff-${attempt}`,
+            hostEpoch: fixture.hostEpoch,
+            rootRunId,
+            successorRunId: `successor-${attempt + 1}`,
+            successorInvocationId: `successor-${attempt + 1}`,
+            claimId: `handoff-claim-${attempt}`,
+          },
+          new AbortController().signal,
+        );
+        assert.ok(request);
+        release[attempt]!.resolve();
+        assert.equal(await request.ready, true);
+        assert.equal(request.commit(), true);
+        assert.equal(await request.sealed, true);
+      } else release[attempt]!.resolve();
+    }
+    await fixture.coordinator.whenIdle(fixture.sessionId);
+    const logical = await readLogicalRuntimeExecution(fixture.stores.runtimeEventStore, {
+      sessionId: fixture.sessionId,
+      turnId: 'repeated-handoff',
+      runId: rootRunId,
+    });
+    assert.deepEqual(logical?.runIds, [rootRunId, 'successor-1', 'successor-2']);
+    assert.equal(logical?.tip.terminalEvent?.status, 'completed');
+    assert.deepEqual(injected, ['steer-0', 'steer-1', 'steer-2']);
+    assert.equal(
+      (await fixture.stores.agentRunStore.listRootTurnAdmissionsForRecovery(fixture.sessionId))
+        .length,
+      1,
+    );
+    assert.equal(
+      (
+        await fixture.coordinator.read({
+          sessionId: fixture.sessionId,
+          turnId: 'repeated-handoff',
+          runId: rootRunId,
+        })
+      ).status,
+      'completed',
+    );
+    assert.deepEqual(fixture.messages.projection(fixture.sessionId).steering, []);
+    assert.equal(fixture.drainRequested(), false);
+  } finally {
+    for (const gate of release) gate.resolve();
+    await fixture.coordinator.close();
+    await fixture.messages.close();
+    await fixture.dispose();
+  }
+});
+
+for (const decision of ['cancel', 'resume', 'detach', 'blocked'] as const) {
+  test(`Root cooperative handoff ${decision} preserves logical ownership`, {
+    timeout: 10_000,
+  }, async () => {
+    const boundary = deferred<void>();
+    const originalContinue = deferred<void>();
+    const requested = deferred<void>();
+    let dispatches = 0;
+    const fixture = await createFailureFixture({
+      continuationSafety: {
+        workspaceIdentity: 'handoff-workspace',
+        availableToolNames: [],
+        backgroundOperationsSettled: decision !== 'blocked',
+      },
+      withInteractions: true,
+      registerBackend: (backends) =>
+        backends.register(
+          'ai-sdk',
+          (context) =>
+            new (class extends FakeBackend {
+              override async *send(input: BackendSendInput): AsyncIterable<SessionEvent> {
+                dispatches += 1;
+                if (!input.continuation) {
+                  await boundary.promise;
+                  if ((await input.handoffBoundary!(new AbortController().signal, 2)) === 'pause')
+                    return;
+                  if (decision === 'blocked') await originalContinue.promise;
+                }
+                yield {
+                  type: 'complete',
+                  id: randomUUID(),
+                  turnId: input.turnId,
+                  ts: Date.now(),
+                  stopReason: 'end_turn',
+                };
+              }
+            })(context),
+        ),
+    });
+    let recovery: RootTurnCoordinator | undefined;
+    try {
+      const request = fixture.manager.requestRunHandoff.bind(fixture.manager);
+      fixture.manager.requestRunHandoff = (...args) => {
+        const result = request(...args);
+        requested.resolve();
+        return result;
+      };
+      const started = await fixture.interactiveTurns.handlers['turn.start'](
+        {
+          sessionId: fixture.sessionId,
+          turnId: 'cooperative-turn',
+          content: { text: 'continue work' },
+        },
+        operationContext(fixture.hostEpoch, fixture.acquireResidency),
+      );
+      assertStartedTurn(started);
+      if (!started.ok) throw new Error('Expected started Turn');
+      const identity = {
+        sessionId: fixture.sessionId,
+        turnId: 'cooperative-turn',
+        runId: started.result.turn.runId,
+      };
+      const preparing = fixture.coordinator.prepareHandoff(
+        fixture.hostEpoch,
+        new AbortController().signal,
+      );
+      await requested.promise;
+      boundary.resolve();
+      const preparation = await preparing;
+      if (decision === 'blocked') {
+        assert.equal(preparation, undefined);
+        originalContinue.resolve();
+      } else {
+        assert.ok(preparation);
+        assert.equal(fixture.coordinator.prepare('another-session').kind, 'busy');
+        if (decision !== 'cancel') assert.equal(await preparation.seal(), true);
+        if (decision === 'detach') {
+          fixture.coordinator.beginDrain();
+          await preparation.detach();
+          await fixture.coordinator.close();
+          assert.equal((await fixture.coordinator.read(identity)).status, 'running');
+          assert.equal(dispatches, 1);
+          recovery = fixture.createRecoveryCoordinator();
+          await recovery.prepareRecovery();
+          await fixture.manager.recoverInterruptedSessionsStrict(fixture.stores);
+          await recovery.recover();
+        } else preparation.cancel();
+      }
+      await (recovery ?? fixture.coordinator).whenIdle(fixture.sessionId);
+      const logical = await readLogicalRuntimeExecution(fixture.stores.runtimeEventStore, identity);
+      assert.equal(logical?.tip.terminalEvent?.status, 'completed');
+      assert.equal(dispatches, decision === 'cancel' || decision === 'blocked' ? 1 : 2);
+      assert.equal(fixture.drainRequested(), false);
+    } finally {
+      boundary.resolve();
+      originalContinue.resolve();
+      await (recovery ?? fixture.coordinator).close();
+      await fixture.messages.close();
+      await fixture.dispose();
+    }
+  });
+}
+
 async function createFailureFixture(options: {
   registerBackend(backends: BackendRegistry): void;
+  afterHandoffSeal?(): Promise<void>;
   directoryHostId?: string;
   corruptSessionRole?: boolean;
   legacyConnectionIdentity?: boolean;
@@ -5152,6 +5544,7 @@ async function createFailureFixture(options: {
   clientCapabilities?: HostClientCapabilityCoordinator;
   continuationSafety?: {
     workspaceIdentity: string;
+    backgroundOperationsSettled?: boolean;
     availableToolNames: readonly string[] | ((sessionId: string) => readonly string[]);
   };
   agentGraphEpochs?: {
@@ -5252,6 +5645,8 @@ async function createFailureFixture(options: {
     hostEpoch,
     root: rootPort,
     durableProof: {
+      readLogicalExecution: (identity) =>
+        readLogicalRuntimeExecutionForRun(stores.runtimeEventStore, identity),
       readRootTurnSourceMessageReceipt: (sessionId, messageId) =>
         stores.agentRunStore.readRootTurnSourceMessageReceipt(sessionId, messageId),
       readImmutableSteeringMessageProof: (sessionId, messageId) =>
@@ -5301,7 +5696,18 @@ async function createFailureFixture(options: {
   const managerDeps = {
     store: stores.sessionStore,
     runStore: stores.agentRunStore,
-    runtimeEventStore: stores.runtimeEventStore,
+    runtimeEventStore: options.afterHandoffSeal
+      ? {
+          ...stores.runtimeEventStore,
+          appendRuntimeEvent: async (
+            ...args: Parameters<typeof stores.runtimeEventStore.appendRuntimeEvent>
+          ) => {
+            const result = await stores.runtimeEventStore.appendRuntimeEvent(...args);
+            if (args[2].actions?.handoffPause) await options.afterHandoffSeal!();
+            return result;
+          },
+        }
+      : stores.runtimeEventStore,
     backends,
     ...(options.childTools ? { childTools: options.childTools } : {}),
     newId: randomUUID,
@@ -5310,9 +5716,11 @@ async function createFailureFixture(options: {
     ...(options.continuationSafety
       ? {
           safeBoundaryResumeEnabled: true,
+          toolBoundaryProtocol: 't1_after_preflight_v1' as const,
           inspectContinuationSafety: async (sessionId: string) => ({
             workspaceIdentity: options.continuationSafety!.workspaceIdentity,
-            backgroundOperationsSettled: true,
+            backgroundOperationsSettled:
+              options.continuationSafety!.backgroundOperationsSettled ?? true,
             availableToolNames:
               typeof options.continuationSafety!.availableToolNames === 'function'
                 ? options.continuationSafety!.availableToolNames(sessionId)
diff --git a/packages/runtime-host/src/__tests__/scheduled-task-coordinator-recovery.test.ts b/packages/runtime-host/src/__tests__/scheduled-task-coordinator-recovery.test.ts
index 13b917e11d..e65fb6845d 100644
--- a/packages/runtime-host/src/__tests__/scheduled-task-coordinator-recovery.test.ts
+++ b/packages/runtime-host/src/__tests__/scheduled-task-coordinator-recovery.test.ts
@@ -18,6 +18,7 @@
  */
 
 import assert from 'node:assert/strict';
+import { deferred, waitFor } from '@maka/core/test-only/async-primitives';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
@@ -394,6 +395,95 @@ test('ScheduledTask with an exact Connection identity reaches Session and AgentR
   }
 });
 
+test('scheduler handoff waits for an admitted native effect and cancellation restores its timer', async () => {
+  const base = await mkdtemp(join(tmpdir(), 'maka-scheduler-handoff-'));
+  const owner = await tryAcquireInteractiveRootOwner(
+    await resolveStorageRoot({ path: join(base, 'root'), kind: 'interactive' }),
+  );
+  assert.ok(owner);
+  const store = await openInteractiveScheduledTaskStoreForWrite(owner.lease);
+  const entered = deferred<void>();
+  const effect = deferred<Record<string, unknown>>();
+  let clock = 1_000;
+  let timer: (() => void) | undefined;
+  let effects = 0;
+  const residency = { release: () => {} };
+  const coordinator = new HostScheduledTaskCoordinator({
+    store,
+    sessions: null as never,
+    runtime: null as never,
+    root: null as never,
+    runtimePolicy: {
+      runtimePolicy: {
+        getSnapshot: async () => ({ policy: { privacy: { incognitoActive: false } } }),
+      },
+    } as never,
+    nativeEffects: {
+      hasWorkspaceService: () => true,
+      callWorkspaceService: async () => {
+        effects += 1;
+        entered.resolve();
+        return effect.promise;
+      },
+    },
+    createSession: async () => {},
+    changes: { publish: () => {} },
+    acquireResidency: () => residency,
+    requestDrain: () => assert.fail('scheduler must not drain'),
+    now: () => clock,
+    setTimeout: (callback) => {
+      timer = callback;
+      return callback;
+    },
+    clearTimeout: () => {
+      timer = undefined;
+    },
+  });
+  try {
+    const task = await store.create(
+      {
+        title: 'Recurring notification',
+        intentBody: 'Notify once per interval',
+        schedule: { kind: 'interval', everySeconds: 60 },
+        effect: { kind: 'notify', channel: 'local' },
+        createdBy: { kind: 'user' },
+      },
+      clock,
+    );
+    await coordinator.prepareRecovery();
+    coordinator.start();
+    await waitFor(() => timer !== undefined);
+    clock = task.nextFireAt!;
+    const fire = timer!;
+    timer = undefined;
+    fire();
+    await entered.promise;
+    const hold = coordinator.holdForHandoff();
+    assert.ok(hold);
+    let settled = false;
+    const ready = hold.settled().then(() => {
+      settled = true;
+    });
+    await Promise.resolve();
+    assert.equal(settled, false);
+    effect.resolve({});
+    await ready;
+    assert.equal(timer, undefined);
+    assert.equal(effects, 1);
+    assert.deepEqual(hold.residencies(), [residency]);
+    assert.equal((await store.listPendingFires()).length, 0);
+    hold.release();
+    await waitFor(() => timer !== undefined);
+    assert.equal(effects, 1);
+  } finally {
+    effect.resolve({});
+    await coordinator.close();
+    store.close();
+    await owner.close();
+    await rm(base, { recursive: true, force: true });
+  }
+});
+
 function execution(suffix: string) {
   return {
     sessionId: `session-${suffix}`,
diff --git a/packages/runtime-host/src/__tests__/session-transcript-reader.test.ts b/packages/runtime-host/src/__tests__/session-transcript-reader.test.ts
index 1da0eab3ce..9569bdfd86 100644
--- a/packages/runtime-host/src/__tests__/session-transcript-reader.test.ts
+++ b/packages/runtime-host/src/__tests__/session-transcript-reader.test.ts
@@ -245,7 +245,7 @@ test('stops scanning a control-only ledger at the cumulative immutable event lim
   const stores = {
     agentRunStore: {},
     runtimeEventStore: {
-      listSessionInvocations: async () => [testInvocation(sessionId)],
+      readRunInvocation: async () => testInvocation(sessionId),
       readRuntimeEventsBounded: async () => ({ status: 'limit_exceeded' as const }),
       scanRuntimeEvents: async (
         _sessionId: string,
@@ -298,7 +298,7 @@ test('stops an oversized active projection before retaining the full RuntimeEven
   const stores = {
     agentRunStore: {},
     runtimeEventStore: {
-      listSessionInvocations: async () => [testInvocation(sessionId)],
+      readRunInvocation: async () => testInvocation(sessionId),
       scanRuntimeEvents: async (
         _sessionId: string,
         _runId: string,
diff --git a/packages/runtime-host/src/client/connection.ts b/packages/runtime-host/src/client/connection.ts
index f78d01a5df..56de724cee 100644
--- a/packages/runtime-host/src/client/connection.ts
+++ b/packages/runtime-host/src/client/connection.ts
@@ -248,6 +248,7 @@ interface ConnectResolvedRuntimeHostInput
 }
 
 export interface RuntimeHostConnection {
+  readonly cooperativeHandoff?: true;
   readonly rootId: string;
   readonly hostEpoch: string;
   readonly connectionId: string;
@@ -348,6 +349,7 @@ interface QueuedDomainFrame {
 type RequestTimeoutScope = 'request' | 'connection';
 
 class RuntimeHostConnectionImpl implements RuntimeHostConnection {
+  readonly cooperativeHandoff?: true;
   readonly rootId: string;
   readonly hostEpoch: string;
   readonly connectionId: string;
@@ -389,6 +391,7 @@ class RuntimeHostConnectionImpl implements RuntimeHostConnection {
       selectedProtocol: number;
       compositionId: string;
       compositionRevision: string;
+      cooperativeHandoff?: true;
     },
     // livenessIntervalMs is validated by connectResolvedRuntimeHost alongside
     // the other connect timeouts, before any transport work happens.
@@ -409,6 +412,7 @@ class RuntimeHostConnectionImpl implements RuntimeHostConnection {
     this.hostEpoch = accepted.hostEpoch;
     this.connectionId = accepted.connectionId;
     this.selectedProtocol = accepted.selectedProtocol;
+    this.cooperativeHandoff = accepted.cooperativeHandoff;
     this.compositionId = accepted.compositionId;
     this.compositionRevision = accepted.compositionRevision;
     this.#getPeerPath = options?.getPeerPath ?? (() => options?.peerPath);
@@ -1468,6 +1472,7 @@ async function exchangeRuntimeHostHandshake(
   const helloProtocol = input.helloProtocol ?? input.protocol;
   const hello: LegacySurfaceClientHello = {
     kind: 'hello',
+    activitySnapshotVersion: 2,
     clientInstanceId: input.clientInstanceId,
     surface: 'desktop',
     protocolMin: helloProtocol.min,
diff --git a/packages/runtime-host/src/client/host-handoff-copy.ts b/packages/runtime-host/src/client/host-handoff-copy.ts
new file mode 100644
index 0000000000..74f0d891b5
--- /dev/null
+++ b/packages/runtime-host/src/client/host-handoff-copy.ts
@@ -0,0 +1,177 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import type { UiLocale } from '@maka/core/ui-locale';
+import type { HostHandoffAction, HostHandoffView } from './host-handoff.js';
+
+/** Shared consequence-oriented copy, not a second lifecycle policy. */
+export function formatHostHandoff(
+  view: HostHandoffView,
+  locale: UiLocale,
+): {
+  title: string;
+  description: string;
+  detail: string;
+  actions: readonly { action: HostHandoffAction; label: string }[];
+} {
+  const zh = locale !== 'en';
+  const tw = locale === 'zh-TW';
+  const titles = tw
+    ? {
+        busy: '背景服務仍在使用中',
+        activity_unknown: '需要確認是否停止背景服務',
+        operator_required: '需要在服務所在位置處理',
+        repair_required: '背景服務需要修復',
+        retry_required: '暫時無法完成交接',
+      }
+    : zh
+      ? {
+          busy: '后台服务仍在使用中',
+          activity_unknown: '需要确认是否停止后台服务',
+          operator_required: '需要在服务所在位置处理',
+          repair_required: '后台服务需要修复',
+          retry_required: '暂时无法完成交接',
+        }
+      : {
+          busy: 'Your background service is still in use',
+          activity_unknown: 'Confirm before stopping the service',
+          operator_required: 'Action is needed where the service runs',
+          repair_required: 'Your background service needs repair',
+          retry_required: 'The handoff could not finish yet',
+        };
+  const descriptions = tw
+    ? {
+        busy: '其他連線或正在執行的工作阻止了自動交接。停止並繼續可能中斷這些工作。',
+        activity_unknown:
+          '這個版本無法提供足夠的活動資訊。停止服務可能中斷其他視窗或裝置上的工作。',
+        operator_required: `目前的用戶端沒有替換此服務的權限。請在 ${view.target.name} 上,由管理該服務的使用者更新或停止服務。`,
+        repair_required: '上次啟動或交接未能完成。可以安全重試;若仍失敗,請複製診斷資訊。',
+        retry_required: '服務狀態發生了變化,或交接尚未完成。可以安全重試,不會預設中斷工作。',
+      }
+    : zh
+      ? {
+          busy: '其它连接或正在执行的工作阻止了自动交接。停止并继续可能中断这些工作。',
+          activity_unknown:
+            '这个版本无法提供足够的活动信息。停止服务可能中断其它窗口或设备上的工作。',
+          operator_required: `当前客户端没有替换此服务的权限。请在 ${view.target.name} 上,由管理该服务的用户更新或停止服务。`,
+          repair_required: '上次启动或交接未能完成。可以安全重试;若仍失败,请复制诊断信息。',
+          retry_required: '服务状态发生了变化,或交接尚未完成。可以安全重试,不会默认中断工作。',
+        }
+      : {
+          busy: 'Other connections or work in progress prevent an automatic handoff. Stopping the service may interrupt that work.',
+          activity_unknown:
+            'This version cannot provide enough activity information. Stopping it may interrupt work in other windows or on other devices.',
+          operator_required: `This client cannot replace the service. Ask its operator to update or stop it on ${view.target.name}.`,
+          repair_required:
+            'The last startup or handoff did not finish. Retry safely, or copy diagnostics if it still fails.',
+          retry_required:
+            'The service changed or the handoff has not finished. A safe retry will not interrupt work by default.',
+        };
+  const activity = view.activity;
+  const facts = activity
+    ? tw
+      ? `${activity.connections} 個連線 · ${activity.activeOperations} 個進行中的操作`
+      : zh
+        ? `${activity.connections} 个连接 · ${activity.activeOperations} 个进行中的操作`
+        : `${activity.connections} connections · ${activity.activeOperations} operations in progress`
+    : '';
+  const waiting = view.mayExitNaturally
+    ? tw
+      ? 'Maka 會持續檢查,並在可以安全繼續時自動繼續。'
+      : zh
+        ? 'Maka 会持续检查,并在可以安全继续时自动继续。'
+        : 'Maka keeps checking and continues automatically when it is safe.'
+    : tw
+      ? 'Maka 會持續檢查。常駐服務不會僅因等待而結束,可能需要你採取操作。'
+      : zh
+        ? 'Maka 会持续检查。常驻服务不会仅因等待而退出,可能需要你采取操作。'
+        : 'Maka keeps checking. A persistent service will not exit just because you wait; action may be needed.';
+  const repairNotice =
+    view.operation === 'repair'
+      ? tw
+        ? '修復將使用目前應用程式配套的版本,可能替換現有服務版本。'
+        : zh
+          ? '修复将使用当前应用配套的版本,可能替换现有服务版本。'
+          : 'Repair uses the version supplied with this app and may replace the installed service version.'
+      : '';
+  const labels = tw
+    ? {
+        cancel: '取消',
+        retry: '安全重試',
+        interrupt: view.operation === 'repair' ? '中斷並修復' : '停止並繼續',
+      }
+    : zh
+      ? {
+          cancel: '取消',
+          retry: '安全重试',
+          interrupt: view.operation === 'repair' ? '中断并修复' : '停止并继续',
+        }
+      : {
+          cancel: 'Cancel',
+          retry: 'Retry safely',
+          interrupt: view.operation === 'repair' ? 'Interrupt and repair' : 'Stop and continue',
+        };
+  const phases = tw
+    ? {
+        checking: '正在檢查服務',
+        staging: '正在準備更新',
+        pausing: '正在等待安全暫停點',
+        retiring: '正在停止舊服務',
+        replacing: '正在替換服務',
+        verifying: '正在確認工作區已就緒',
+      }
+    : zh
+      ? {
+          checking: '正在检查服务',
+          staging: '正在准备更新',
+          pausing: '正在等待安全暂停点',
+          retiring: '正在停止旧服务',
+          replacing: '正在替换服务',
+          verifying: '正在确认工作区已就绪',
+        }
+      : {
+          checking: 'Checking the service',
+          staging: 'Preparing the update',
+          pausing: 'Waiting for a safe pause point',
+          retiring: 'Stopping the previous service',
+          replacing: 'Replacing the service',
+          verifying: 'Verifying your workspace is ready',
+        };
+  return {
+    title:
+      view.state === 'progress'
+        ? tw
+          ? '正在繼續開啟工作區'
+          : zh
+            ? '正在继续打开工作区'
+            : 'Continuing to your workspace'
+        : titles[view.reason],
+    description:
+      view.state === 'progress' ? phases[view.phase ?? 'checking'] : descriptions[view.reason],
+    detail:
+      view.state === 'progress'
+        ? tw
+          ? '正在完成交接或安全收尾,請稍候。'
+          : zh
+            ? '正在完成交接或安全收尾,请稍候。'
+            : 'Finishing the handoff or its safe recovery. Please wait.'
+        : [facts, waiting, repairNotice, view.operatorStep].filter(Boolean).join('\n'),
+    actions: view.actions.map((action) => ({ action, label: labels[action] })),
+  };
+}
diff --git a/packages/runtime-host/src/client/host-handoff.ts b/packages/runtime-host/src/client/host-handoff.ts
new file mode 100644
index 0000000000..f1f0804b70
--- /dev/null
+++ b/packages/runtime-host/src/client/host-handoff.ts
@@ -0,0 +1,365 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { randomUUID } from 'node:crypto';
+import { isHostActivityIdle, type HostActivitySnapshot } from '../protocol/host-status.js';
+import type { RuntimeHostRetirementMode } from './host-retirement.js';
+import { RuntimeHostPermanentReconnectError } from './reconnect-lifecycle.js';
+import { formatHostHandoff } from './host-handoff-copy.js';
+import { redactSecrets } from '@maka/core/redaction';
+
+export type HostHandoffAction = 'cancel' | 'retry' | 'interrupt';
+export type HostHandoffPhase =
+  | 'checking'
+  | 'staging'
+  | 'pausing'
+  | 'retiring'
+  | 'replacing'
+  | 'verifying';
+
+export interface HostHandoffTarget {
+  readonly name: string;
+  readonly location: 'local' | 'remote';
+  readonly rootId?: string;
+  readonly hostEpoch?: string;
+}
+
+/** An owner adapter binds this capability to its exact observed deployment/process lifetime.
+ * It must revalidate that identity and fence admission inside the existing transaction.
+ * Neither a Surface choice nor this in-memory coordinator grants mutation authority.
+ */
+export interface HostHandoffReplacement {
+  readonly kind: 'replace' | 'repair';
+  readonly canReplaceIdle: boolean;
+  readonly canInterrupt: boolean;
+  execute(
+    policy: RuntimeHostRetirementMode,
+    progress: (phase: HostHandoffPhase) => void,
+    consent: 'automatic' | 'explicit',
+    signal?: AbortSignal,
+  ): Promise<HostHandoffReplacementResult>;
+}
+
+export type HostHandoffReplacementResult =
+  | { readonly kind: 'completed' | 'active_work' | 'changed' }
+  | { readonly kind: 'recovery_required'; readonly diagnostic: string };
+
+export interface HostHandoffBlocker {
+  /** Includes all authority evidence that invalidates consent when it changes. */
+  readonly identity: string;
+  readonly target: HostHandoffTarget;
+  readonly reason: 'upgrade' | 'repair' | 'unavailable';
+  readonly activity?: HostActivitySnapshot;
+  readonly mayExitNaturally: boolean;
+  readonly replacement?: HostHandoffReplacement;
+  readonly operatorStep?: string;
+  readonly diagnostic?: string;
+}
+
+export type HostHandoffObservation<T> =
+  | { readonly kind: 'ready'; readonly value: T }
+  | { readonly kind: 'blocked'; readonly blocker: HostHandoffBlocker };
+
+/** Data-only projection. A Surface cannot supply policy, a target, or a transaction. */
+export interface HostHandoffView {
+  readonly revision: string;
+  readonly target: HostHandoffTarget;
+  readonly state: 'attention' | 'progress';
+  readonly reason:
+    | 'busy'
+    | 'activity_unknown'
+    | 'operator_required'
+    | 'repair_required'
+    | 'retry_required';
+  readonly activity?: HostActivitySnapshot;
+  readonly mayExitNaturally: boolean;
+  readonly operation?: 'replace' | 'repair';
+  readonly phase?: HostHandoffPhase;
+  readonly actions: readonly HostHandoffAction[];
+  readonly defaultAction: 'cancel';
+  readonly operatorStep?: string;
+  readonly diagnostic?: string;
+}
+
+export interface HostHandoffSurface {
+  update(view: HostHandoffView): void;
+  close(): void;
+}
+
+export type OpenHostHandoffSurface = (
+  submit: (revision: string, action: HostHandoffAction) => void,
+) => HostHandoffSurface;
+
+export class HostHandoffCancelledError extends RuntimeHostPermanentReconnectError {
+  readonly code = 'runtime_host_handoff_cancelled';
+  constructor() {
+    super('Runtime Host handoff was cancelled');
+    this.name = 'HostHandoffCancelledError';
+  }
+}
+
+/** Noninteractive callers receive the same decision instead of prompting or silently stopping work. */
+export class HostHandoffRequiredError extends RuntimeHostPermanentReconnectError {
+  readonly code = 'runtime_host_handoff_required';
+  constructor(readonly view: HostHandoffView) {
+    const copy = formatHostHandoff(view, 'en');
+    super([copy.title, copy.description, copy.detail, view.diagnostic].filter(Boolean).join('\n'));
+    this.name = 'HostHandoffRequiredError';
+  }
+}
+
+/** One live attempt; persisted deployment transactions remain the sole recovery authority. */
+export async function runHostHandoff<T extends { close(): Promise<void> }>(input: {
+  observe(signal?: AbortSignal): Promise<HostHandoffObservation<T>>;
+  openSurface?: OpenHostHandoffSurface;
+  signal?: AbortSignal;
+  pollIntervalMs?: number;
+}): Promise<T> {
+  const interval = input.pollIntervalMs ?? 1_000;
+  if (!Number.isFinite(interval) || interval <= 0)
+    throw new RangeError('Invalid handoff observation interval');
+  let surface: HostHandoffSurface | undefined;
+  let view: HostHandoffView | undefined;
+  let signature: string | undefined;
+  let choice: { revision: string; action: HostHandoffAction } | undefined;
+  let wake: (() => void) | undefined;
+  let attemptAbort: AbortController | undefined;
+  let cancelled = false;
+  // Admission can refuse an apparently idle snapshot. Do not turn that race
+  // (or a broken successor) into an automatic replacement storm.
+  const attempted = new Set<string>();
+  let automaticAttempts = 0;
+  let recovery: { identity: string; diagnostic: string } | undefined;
+  const publish = (next: HostHandoffView) => {
+    view = next;
+    surface?.update(next);
+  };
+  const submit = (revision: string, action: HostHandoffAction) => {
+    if (!view || revision !== view.revision || !view.actions.includes(action)) return;
+    if (view.state === 'progress') {
+      if (action !== 'cancel' || cancelled) return;
+      cancelled = true;
+      attemptAbort?.abort(new HostHandoffCancelledError());
+      publish({ ...view, revision: randomUUID(), actions: [] });
+      return;
+    }
+    if (choice) return;
+    choice = { revision, action };
+    wake?.();
+  };
+  try {
+    for (;;) {
+      input.signal?.throwIfAborted();
+      if (cancelled) throw new HostHandoffCancelledError();
+      if (choice?.action === 'cancel') throw new HostHandoffCancelledError();
+      // Every action, including an explicit interruption, gets a fresh observation.
+      // Final identity/admission fencing is still the mutation adapter's responsibility.
+      let observed: HostHandoffObservation<T>;
+      try {
+        observed = await input.observe(input.signal);
+      } catch (error) {
+        input.signal?.throwIfAborted();
+        if (!view) throw error;
+        // Lost observation is not permission to reuse the last mutation capability.
+        // Keep this journey visible and retry without chaining a fatal dialog.
+        observed = {
+          kind: 'blocked',
+          blocker: {
+            identity: JSON.stringify(['unavailable', view.target]),
+            target: view.target,
+            reason: 'unavailable',
+            mayExitNaturally: false,
+            diagnostic: boundedDiagnostic(error),
+          },
+        };
+      }
+      if (observed.kind === 'ready') {
+        if (
+          input.signal?.aborted ||
+          (choice as { action: HostHandoffAction } | undefined)?.action === 'cancel'
+        ) {
+          await observed.value.close();
+          input.signal?.throwIfAborted();
+          throw new HostHandoffCancelledError();
+        }
+        return observed.value;
+      }
+      input.signal?.throwIfAborted();
+      // Cancellation belongs to the attempt, not to the observed Host. A new
+      // epoch or newly idle snapshot must not erase a click made during observe.
+      if ((choice as { action: HostHandoffAction } | undefined)?.action === 'cancel') {
+        throw new HostHandoffCancelledError();
+      }
+      const blocker = observed.blocker;
+      if (recovery?.identity !== blocker.identity) recovery = undefined;
+      const nextSignature = blockerSignature(blocker);
+      if (signature !== nextSignature) {
+        signature = nextSignature;
+        choice = undefined;
+        publish(projectBlocker(blocker, randomUUID(), recovery?.diagnostic));
+      }
+      const current = view!;
+      const selected = choice as { revision: string; action: HostHandoffAction } | undefined;
+      choice = undefined;
+      if (selected?.action === 'cancel') throw new HostHandoffCancelledError();
+      const cooperative =
+        blocker.target.location === 'local' &&
+        blocker.activity?.cooperativeHandoff === true &&
+        blocker.activity.connections === 0 &&
+        blocker.activity.activeOperations === 0;
+      const automatic =
+        !recovery &&
+        automaticAttempts < 3 &&
+        !attempted.has(nextSignature) &&
+        blocker.replacement?.canReplaceIdle &&
+        blocker.activity &&
+        (isHostActivityIdle(blocker.activity) || cooperative);
+      const interrupt = selected?.revision === current.revision && selected.action === 'interrupt';
+      const retry = selected?.revision === current.revision && selected.action === 'retry';
+      if (
+        (automatic || interrupt || (retry && blocker.replacement?.canReplaceIdle)) &&
+        blocker.replacement
+      ) {
+        if (automatic) {
+          attempted.add(nextSignature);
+          automaticAttempts += 1;
+        }
+        attemptAbort = new AbortController();
+        const operationSignal = input.signal
+          ? AbortSignal.any([input.signal, attemptAbort.signal])
+          : attemptAbort.signal;
+        const progress = (phase: HostHandoffPhase) =>
+          publish({
+            ...current,
+            revision: randomUUID(),
+            state: 'progress',
+            phase: cooperative && !interrupt && phase === 'retiring' ? 'pausing' : phase,
+            actions: cancelled ? [] : ['cancel'],
+          });
+        if (input.openSurface) surface ??= input.openSurface(submit);
+        progress(cooperative && !interrupt ? 'pausing' : 'checking');
+        // Do not abandon an irreversible cutover when the Surface closes. Its
+        // transaction settles (or persists recovery) before cancellation is observed.
+        let result: HostHandoffReplacementResult;
+        try {
+          result = await blocker.replacement.execute(
+            interrupt ? 'interrupt_active_work' : 'refuse_active_work',
+            progress,
+            automatic && !retry && !interrupt ? 'automatic' : 'explicit',
+            operationSignal,
+          );
+        } catch (error) {
+          result = { kind: 'recovery_required', diagnostic: boundedDiagnostic(error) };
+        } finally {
+          attemptAbort = undefined;
+        }
+        recovery =
+          result.kind === 'recovery_required'
+            ? { identity: blocker.identity, diagnostic: result.diagnostic.slice(0, 8_192) }
+            : undefined;
+        // A completed attempt is not proof of readiness; observe the successor.
+        signature = undefined;
+        continue;
+      }
+      if (selected?.action === 'retry') {
+        // Explicit retry permits another safe probe, never an implicit interruption.
+        attempted.delete(nextSignature);
+        automaticAttempts = 0;
+        recovery = undefined;
+        signature = undefined;
+        continue;
+      }
+      const attention = projectBlocker(blocker, current.revision, recovery?.diagnostic);
+      if (!input.openSurface) throw new HostHandoffRequiredError(attention);
+      surface ??= input.openSurface(submit);
+      publish(attention);
+      await new Promise<void>((resolve, reject) => {
+        const finish = (error?: unknown) => {
+          clearTimeout(timer);
+          input.signal?.removeEventListener('abort', abort);
+          wake = undefined;
+          if (error !== undefined) reject(error);
+          else resolve();
+        };
+        const abort = () => finish(input.signal?.reason);
+        const timer = setTimeout(finish, interval);
+        wake = () => finish();
+        input.signal?.addEventListener('abort', abort, { once: true });
+        if (input.signal?.aborted) abort();
+        else if (choice) finish();
+      });
+    }
+  } finally {
+    surface?.close();
+  }
+}
+
+function projectBlocker(
+  blocker: HostHandoffBlocker,
+  revision: string,
+  recovery?: string,
+): HostHandoffView {
+  const replacement = blocker.replacement;
+  return {
+    revision,
+    target: blocker.target,
+    state: 'attention',
+    reason:
+      blocker.reason === 'unavailable'
+        ? 'retry_required'
+        : recovery || blocker.reason === 'repair'
+          ? 'repair_required'
+          : !replacement
+            ? 'operator_required'
+            : !blocker.activity
+              ? 'activity_unknown'
+              : isHostActivityIdle(blocker.activity)
+                ? 'retry_required'
+                : 'busy',
+    ...(blocker.activity ? { activity: blocker.activity } : {}),
+    mayExitNaturally: blocker.mayExitNaturally,
+    ...(replacement ? { operation: replacement.kind } : {}),
+    actions: replacement?.canInterrupt ? ['cancel', 'retry', 'interrupt'] : ['cancel', 'retry'],
+    defaultAction: 'cancel',
+    ...(blocker.operatorStep ? { operatorStep: blocker.operatorStep } : {}),
+    ...((recovery ?? blocker.diagnostic)
+      ? { diagnostic: redactSecrets((recovery ?? blocker.diagnostic)!).slice(0, 8_192) }
+      : {}),
+  };
+}
+
+function blockerSignature(blocker: HostHandoffBlocker): string {
+  const { processUptimeSeconds: _uptime, ...activity } = blocker.activity ?? {};
+  return JSON.stringify([
+    blocker.identity,
+    blocker.target,
+    blocker.reason,
+    activity,
+    blocker.mayExitNaturally,
+    blocker.replacement?.kind,
+    blocker.replacement?.canReplaceIdle,
+    blocker.replacement?.canInterrupt,
+    blocker.operatorStep,
+    blocker.diagnostic,
+  ]);
+}
+
+function boundedDiagnostic(error: unknown): string {
+  return redactSecrets(error instanceof Error ? error.message : String(error)).slice(0, 8_192);
+}
diff --git a/packages/runtime-host/src/client/host-retirement.ts b/packages/runtime-host/src/client/host-retirement.ts
index 5696f529fa..203fedec0d 100644
--- a/packages/runtime-host/src/client/host-retirement.ts
+++ b/packages/runtime-host/src/client/host-retirement.ts
@@ -30,17 +30,37 @@ export type RuntimeHostRetirementPreparation = OperationOutput<'host.upgrade.pre
  * transport detail here so lifecycle owners can model the operation as
  * retirement instead of spreading update-specific authority.
  */
-export function prepareConnectedRuntimeHostRetirement(
+export async function prepareConnectedRuntimeHostRetirement(
   connection: RuntimeHostConnection,
   mode: RuntimeHostRetirementMode,
   timeoutMs?: number,
+  signal?: AbortSignal,
 ): Promise<RuntimeHostRetirementPreparation> {
-  return connection.request(
-    'host.upgrade.prepare',
-    {
-      expectedHostEpoch: connection.hostEpoch,
-      allowInterruptActiveTasks: mode === 'interrupt_active_work',
-    },
-    timeoutMs,
-  );
+  signal?.throwIfAborted();
+  // Retirement uses a dedicated lifecycle connection. Closing it cancels the
+  // Host's reversible preparation; a committed retirement remains committed.
+  const cancel = () => {
+    void connection.close().catch(() => undefined);
+  };
+  signal?.addEventListener('abort', cancel, { once: true });
+  try {
+    return await connection.request(
+      'host.upgrade.prepare',
+      {
+        expectedHostEpoch: connection.hostEpoch,
+        allowInterruptActiveTasks: mode === 'interrupt_active_work',
+        ...(mode === 'refuse_active_work' && connection.cooperativeHandoff
+          ? { allowCooperativeHandoff: true }
+          : {}),
+      },
+      timeoutMs,
+    );
+  } catch (error) {
+    // Cancellation is not an unavailable protocol: lifecycle fallback must
+    // never turn this deliberate disconnect into supervisor interruption.
+    signal?.throwIfAborted();
+    throw error;
+  } finally {
+    signal?.removeEventListener('abort', cancel);
+  }
 }
diff --git a/packages/runtime-host/src/client/index.ts b/packages/runtime-host/src/client/index.ts
index 62bda5e1d8..052caee5fd 100644
--- a/packages/runtime-host/src/client/index.ts
+++ b/packages/runtime-host/src/client/index.ts
@@ -17,6 +17,8 @@
  * under the License.
  */
 
+export * from './host-handoff.js';
+export { formatHostHandoff } from './host-handoff-copy.js';
 export {
   RuntimeHostManagedActivationError,
   activateRuntimeHostManagedDeployment,
diff --git a/packages/runtime-host/src/client/remote-compatibility-error.ts b/packages/runtime-host/src/client/remote-compatibility-error.ts
index 3e276cf263..8329e43045 100644
--- a/packages/runtime-host/src/client/remote-compatibility-error.ts
+++ b/packages/runtime-host/src/client/remote-compatibility-error.ts
@@ -48,6 +48,7 @@ export class RuntimeHostRemoteCompatibilityError extends RuntimeHostPermanentRec
   readonly name = 'RuntimeHostRemoteCompatibilityError';
   readonly code = RUNTIME_HOST_REMOTE_INCOMPATIBLE_CODE;
   readonly details: RuntimeHostRemoteCompatibilityDetails;
+  readonly hostEpoch: string;
 
   constructor(profileId: string, handshake: HostIncompatible) {
     const details = Object.freeze({
@@ -68,6 +69,7 @@ export class RuntimeHostRemoteCompatibilityError extends RuntimeHostPermanentRec
     });
     super(formatRuntimeHostRemoteCompatibilityMessage(details));
     this.details = details;
+    this.hostEpoch = handshake.hostEpoch;
   }
 }
 
diff --git a/packages/runtime-host/src/operator/index.ts b/packages/runtime-host/src/operator/index.ts
index 8b16af62ef..d4b4cbd8e3 100644
--- a/packages/runtime-host/src/operator/index.ts
+++ b/packages/runtime-host/src/operator/index.ts
@@ -17,6 +17,7 @@
  * under the License.
  */
 
+export { RUNTIME_HOST_OPERATOR_RETIREMENT_CANCELLATION_ENV } from './retirement-cancellation.js';
 export {
   RUNTIME_HOST_ACTIVATION_ERROR_CODE_MAX_BYTES,
   RUNTIME_HOST_ACTIVATION_ERROR_MESSAGE_MAX_BYTES,
diff --git a/packages/runtime-host/src/operator/retirement-cancellation.ts b/packages/runtime-host/src/operator/retirement-cancellation.ts
new file mode 100644
index 0000000000..6b8db56cf0
--- /dev/null
+++ b/packages/runtime-host/src/operator/retirement-cancellation.ts
@@ -0,0 +1,22 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/** EOF on inherited stdin cancels only the first retirement, never its transaction or rollback. */
+export const RUNTIME_HOST_OPERATOR_RETIREMENT_CANCELLATION_ENV =
+  'MAKA_RUNTIME_HOST_OPERATOR_RETIREMENT_CANCELLATION_STDIN';
diff --git a/packages/runtime-host/src/protocol/host-status.ts b/packages/runtime-host/src/protocol/host-status.ts
index a4506b6df2..a361c8f11c 100644
--- a/packages/runtime-host/src/protocol/host-status.ts
+++ b/packages/runtime-host/src/protocol/host-status.ts
@@ -24,6 +24,7 @@ import {
   requireExactRecord,
   requireId,
   requireRecord,
+  requireShapedRecord,
   requireString,
   requireUtf8String,
 } from './codec.js';
@@ -41,19 +42,25 @@ export interface HostActivitySnapshot {
   readonly activeOperations: number;
   readonly processUptimeSeconds: number;
   readonly residencies: readonly { readonly label: string; readonly count: number }[];
+  /** Negotiated maintenance evidence. Absent on released Hosts: every residency is conservative. */
+  readonly drainResidencies?: number;
+  readonly cooperativeHandoff?: boolean;
 }
 
 export function isHostActivityIdle(activity: HostActivitySnapshot): boolean {
   return (
     activity.connections === 0 &&
     activity.activeOperations === 0 &&
-    activity.residencies.length === 0
+    (activity.drainResidencies === undefined
+      ? activity.residencies.length === 0
+      : activity.drainResidencies === 0)
   );
 }
 
 export interface HostUpgradePrepareInput {
   readonly expectedHostEpoch: string;
   readonly allowInterruptActiveTasks: boolean;
+  readonly allowCooperativeHandoff?: boolean;
 }
 
 export type HostUpgradePrepareResult =
@@ -219,16 +226,29 @@ function requireUpgradeBlockingActivity(value: unknown): boolean {
 }
 
 export function decodeHostActivitySnapshot(value: unknown): HostActivitySnapshot {
-  const record = requireExactRecord(value, 'Runtime Host activity', [
-    'connections',
-    'activeOperations',
-    'processUptimeSeconds',
-    'residencies',
-  ]);
+  const record = requireShapedRecord(
+    value,
+    'Runtime Host activity',
+    ['connections', 'activeOperations', 'processUptimeSeconds', 'residencies'],
+    ['drainResidencies', 'cooperativeHandoff'],
+  );
   if (!Array.isArray(record.residencies) || record.residencies.length > 128) {
     throw invalidProtocolFrame('Invalid Runtime Host activity residencies');
   }
   return {
+    ...(record.cooperativeHandoff === undefined
+      ? {}
+      : {
+          cooperativeHandoff: requireBoolean(
+            record.cooperativeHandoff,
+            'Runtime Host cooperative handoff capability',
+          ),
+        }),
+    ...(record.drainResidencies === undefined
+      ? {}
+      : {
+          drainResidencies: requireCount(record.drainResidencies, 'Runtime Host drain residencies'),
+        }),
     connections: requireCount(record.connections, 'Runtime Host activity connections'),
     activeOperations: requireCount(
       record.activeOperations,
@@ -252,16 +272,26 @@ export function decodeHostActivitySnapshot(value: unknown): HostActivitySnapshot
 }
 
 function decodeHostUpgradePrepareInput(value: unknown): HostUpgradePrepareInput {
-  const record = requireExactRecord(value, 'Runtime Host upgrade prepare input', [
-    'expectedHostEpoch',
-    'allowInterruptActiveTasks',
-  ]);
+  const record = requireShapedRecord(
+    value,
+    'Runtime Host upgrade prepare input',
+    ['expectedHostEpoch', 'allowInterruptActiveTasks'],
+    ['allowCooperativeHandoff'],
+  );
   return {
     expectedHostEpoch: requireId(record.expectedHostEpoch, 'Runtime Host expected Host Epoch'),
     allowInterruptActiveTasks: requireBoolean(
       record.allowInterruptActiveTasks,
       'Runtime Host upgrade interrupt authority',
     ),
+    ...(record.allowCooperativeHandoff === undefined
+      ? {}
+      : {
+          allowCooperativeHandoff: requireBoolean(
+            record.allowCooperativeHandoff,
+            'Runtime Host cooperative handoff authority',
+          ),
+        }),
   };
 }
 
diff --git a/packages/runtime-host/src/protocol/index.ts b/packages/runtime-host/src/protocol/index.ts
index 4ec1d4da53..736b0e8746 100644
--- a/packages/runtime-host/src/protocol/index.ts
+++ b/packages/runtime-host/src/protocol/index.ts
@@ -101,7 +101,9 @@ export const RUNTIME_HOST_REGISTRATION_SCHEMA_VERSION = 1 as const;
 export const RUNTIME_HOST_PROTOCOL_VERSION = 0 as const;
 // Increment when the same protocol version no longer guarantees safe Client-Host
 // interoperability. Mismatches are rejected before domain commands are admitted.
-export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 121 as const;
+export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 122 as const;
+// 122: Authenticated physical handoff continuations retain logical Turn identity.
+// Older peers cannot decode the handoff source and sealed invocation facts.
 // 121: Host diagnostics report `upgradeBlockingActivity`, the Host's
 // authoritative activity answer for maintenance probes, computed by the same
 // authority that gates `host.upgrade.prepare`. Older Clients reject the
@@ -381,6 +383,8 @@ export interface ClientHello {
   compositionId: string;
   generation?: string;
   takeover?: { expectedHostEpoch: string };
+  /** Opt in before a Host adds maintenance evidence to the strict activity record. */
+  activitySnapshotVersion?: 2;
 }
 
 export interface HostAccepted {
@@ -393,6 +397,7 @@ export interface HostAccepted {
   compositionId: string;
   compositionRevision: string;
   state: Exclude<HostLifecycleState, 'draining'>;
+  cooperativeHandoff?: true;
 }
 
 export interface HostIncompatible {
@@ -489,6 +494,7 @@ export function decodeClientFrame(value: unknown): ClientFrame {
     }
     return {
       kind: 'hello',
+      ...(frame.activitySnapshotVersion === 2 ? { activitySnapshotVersion: 2 as const } : {}),
       clientInstanceId: requireClientInstanceId(frame.clientInstanceId),
       protocolMin,
       protocolMax,
@@ -507,8 +513,12 @@ export function decodeClientFrame(value: unknown): ClientFrame {
 export function decodeHostFrame(value: unknown): HostFrame {
   const frame = requireRecord(value, 'host frame');
   if (frame.kind === 'accepted') {
+    if (frame.cooperativeHandoff !== undefined && frame.cooperativeHandoff !== true) {
+      throw invalidProtocolFrame('Invalid Runtime Host cooperative handoff capability');
+    }
     return {
       kind: 'accepted',
+      ...(frame.cooperativeHandoff === true ? { cooperativeHandoff: true as const } : {}),
       rootId: requireHostRootId(frame.rootId),
       hostEpoch: requireId(frame.hostEpoch, 'hostEpoch'),
       connectionId: requireId(frame.connectionId, 'connectionId'),
diff --git a/packages/runtime-host/src/server/canonical-turn-snapshot.ts b/packages/runtime-host/src/server/canonical-turn-snapshot.ts
index 1ba5b1968c..321eea9431 100644
--- a/packages/runtime-host/src/server/canonical-turn-snapshot.ts
+++ b/packages/runtime-host/src/server/canonical-turn-snapshot.ts
@@ -21,6 +21,7 @@ import { type ContextCompactionOutcome } from '@maka/core/events';
 import { truncateUtf8 } from '@maka/core/diagnostic-log';
 import { redactSecrets } from '@maka/core/redaction';
 import { readRunInvocation } from '@maka/core/runtime-event-store';
+import { readLogicalRuntimeExecution } from '@maka/core/runtime-logical-execution';
 import type { RuntimeInvocationRecord } from '@maka/core/runtime-invocation';
 import { classifyTerminalRuntimeLedger } from '@maka/runtime/terminal-run-commit';
 import type { ExecutionStoresWriter } from '@maka/storage/execution-stores';
@@ -49,8 +50,10 @@ export async function readCanonicalTurnSnapshot(
     throw new Error('Admitted Turn identity does not match its invocation');
   }
 
-  const runtimeEvents = await stores.runtimeEventStore.readImmutableRuntimeEvents(sessionId, runId);
-  const terminal = classifyTerminalRuntimeLedger(run, runtimeEvents);
+  const logical = await readLogicalRuntimeExecution(stores.runtimeEventStore, identity, run);
+  if (!logical) throw new Error('Admitted logical execution disappeared');
+  if (logical.pendingHandoff) return { sessionId, turnId, runId, status: 'running' };
+  const terminal = classifyTerminalRuntimeLedger(logical.tip, logical.events);
   if (terminal.kind === 'fact') {
     const fact = terminal.fact;
     if (fact.runStatus === 'completed') {
@@ -101,7 +104,7 @@ export async function readCanonicalTurnSnapshot(
   }
   // No terminal event means the run is still open. Whether it is parked is the
   // pending-interaction store's answer, not something the run restates.
-  const parked = await hasPendingInteraction(stores, sessionId, runId);
+  const parked = await hasPendingInteraction(stores, sessionId, logical.tip.runId);
   return { sessionId, turnId, runId, status: parked ? 'waiting_for_user' : 'running' };
 }
 
diff --git a/packages/runtime-host/src/server/connection-session.ts b/packages/runtime-host/src/server/connection-session.ts
index 2c7190c021..59819c44bb 100644
--- a/packages/runtime-host/src/server/connection-session.ts
+++ b/packages/runtime-host/src/server/connection-session.ts
@@ -55,7 +55,10 @@ import {
   hasRuntimeHostOperationGrant,
 } from './connection-authority.js';
 
-type AcceptedConnectionContext = Omit<ConnectionContext, 'acquireResidency' | 'principal'> & {
+type AcceptedConnectionContext = Omit<
+  ConnectionContext,
+  'acquireResidency' | 'principal' | 'inputClosedSignal'
+> & {
   readonly clientInstanceId: string;
   readonly authority: RuntimeHostConnectionAuthority;
 };
@@ -90,7 +93,7 @@ export class RuntimeHostConnectionSession {
   #clientCapabilities: ClientCapabilityConnection | undefined;
   #clientCapabilityCloseTask: Promise<void> | undefined;
   #hostChanges: HostChangeSubscription | undefined;
-  #inputClosed = false;
+  readonly #inputClosedAbort = new AbortController();
   #closed = false;
 
   constructor(options: RuntimeHostConnectionSessionOptions) {
@@ -121,7 +124,7 @@ export class RuntimeHostConnectionSession {
   }
 
   async #closeAfterDispatchedReplies(): Promise<void> {
-    this.#inputClosed = true;
+    this.#inputClosedAbort.abort();
     this.#detachContinuity();
     this.#detachClientCapabilities();
     this.#detachHostChanges();
@@ -226,6 +229,7 @@ export class RuntimeHostConnectionSession {
           : undefined;
       const response = await dispatchOperation(frame, this.#options.resolveHandlers(), {
         ...this.#options.connection,
+        inputClosedSignal: this.#inputClosedAbort.signal,
         principal: this.#options.connection.authority.principalId,
         principalKind: this.#options.connection.authority.principalKind,
         ...(this.#options.connection.authority.credentialId
@@ -258,7 +262,7 @@ export class RuntimeHostConnectionSession {
   }
 
   #ensureContinuity(): SessionContinuityConnection | undefined {
-    if (this.#closed || this.#inputClosed) return;
+    if (this.#closed || this.#inputClosedAbort.signal.aborted) return;
     const service = this.#options.resolveContinuity();
     if (!service) return;
     if (this.#continuityService && this.#continuityService !== service) {
@@ -286,7 +290,7 @@ export class RuntimeHostConnectionSession {
   }
 
   #ensureClientCapabilities(): ClientCapabilityConnection | undefined {
-    if (this.#closed || this.#inputClosed) return;
+    if (this.#closed || this.#inputClosedAbort.signal.aborted) return;
     // Guests observe and submit approval requests; they cannot provide Client
     // Capabilities or directly admit a Turn. In particular, their pending and
     // finalized connections may overlap while the credential becomes bound to
@@ -339,7 +343,7 @@ export class RuntimeHostConnectionSession {
   }
 
   attachGlobalChanges(): void {
-    if (this.#closed || this.#inputClosed) return;
+    if (this.#closed || this.#inputClosedAbort.signal.aborted) return;
     const service = this.#options.resolveHostChanges?.();
     if (!service || this.#hostChanges) return;
     const sharedSessionId =
@@ -397,7 +401,7 @@ export class RuntimeHostConnectionSession {
   #teardown(): void {
     if (this.#closed) return;
     this.#closed = true;
-    this.#inputClosed = true;
+    this.#inputClosedAbort.abort();
     this.#detachContinuity();
     this.#detachClientCapabilities();
     this.#detachHostChanges();
diff --git a/packages/runtime-host/src/server/execution-composition.ts b/packages/runtime-host/src/server/execution-composition.ts
index c0e503699c..876ac66403 100644
--- a/packages/runtime-host/src/server/execution-composition.ts
+++ b/packages/runtime-host/src/server/execution-composition.ts
@@ -25,6 +25,7 @@ import { NO_REAL_CONNECTION_CODE } from '@maka/core/connection-error-copy';
 import type { RuntimeExecutionConnection } from '@maka/core/llm-connections';
 import { generalizedErrorMessage } from '@maka/core/redaction';
 import { emptyPlanSessionState } from '@maka/core/plan';
+import { readLogicalRuntimeExecutionForRun } from '@maka/core/runtime-logical-execution';
 import type { PermissionMode } from '@maka/core/permission';
 import {
   runtimeInvocationOutcome,
@@ -127,7 +128,10 @@ import { HostGoalCoordinator } from './goal-coordinator.js';
 import { HostGoalExecutionCoordinator } from './goal-execution-coordinator.js';
 import { HostHostedExecutionCoordinator } from './hosted-execution-coordinator.js';
 import { HostHostedExecutionRunner } from './hosted-execution-runner.js';
-import { executeHostedExecutionToSettlement } from './hosted-execution-wait.js';
+import {
+  executeHostedExecutionToSettlement,
+  waitForHostedExecutionIdleOrAbort,
+} from './hosted-execution-wait.js';
 import type { RuntimeHostComposition, RuntimeHostCompositionContext } from './host-kernel.js';
 import {
   beginRuntimeHostDomainModuleDrain,
@@ -588,6 +592,8 @@ export async function createExecutionRuntimeHostComposition(
       hostEpoch: context.hostEpoch,
       root: rootPort,
       durableProof: {
+        readLogicalExecution: (identity) =>
+          readLogicalRuntimeExecutionForRun(stores.runtimeEventStore, identity),
         readRootTurnSourceMessageReceipt: (sessionId, messageId) =>
           stores.agentRunStore.readRootTurnSourceMessageReceipt(sessionId, messageId),
         readImmutableSteeringMessageProof: (sessionId, messageId) =>
@@ -2062,6 +2068,58 @@ export async function createExecutionRuntimeHostComposition(
       continuity: continuityCoordinator,
       clientCapabilities,
       hostChanges,
+      prepareHandoff: async (hostEpoch, signal) => {
+        if (draining || signal.aborted) return undefined;
+        const goalHold = goal?.holdForHandoff();
+        const scheduleHold = scheduledTasks?.holdForHandoff();
+        let root: Awaited<ReturnType<RootTurnCoordinator['prepareHandoff']>>;
+        let detached = false;
+        const cancel = () => {
+          if (detached) return;
+          root?.cancel();
+          goalHold?.release();
+          scheduleHold?.release();
+          signal.removeEventListener('abort', cancel);
+        };
+        signal.addEventListener('abort', cancel, { once: true });
+        try {
+          if (!goalHold || !scheduleHold) {
+            cancel();
+            return undefined;
+          }
+          await waitForHostedExecutionIdleOrAbort(
+            Promise.all([goalHold.settled(), scheduleHold.settled()]).then(() => undefined),
+            signal,
+          );
+          root = await requireRootCoordinator(coordinator).prepareHandoff(hostEpoch, signal);
+          if (!root) {
+            cancel();
+            return undefined;
+          }
+          const prepared = root;
+          return {
+            seal: () => prepared.seal(),
+            residencies: async () => {
+              await waitForHostedExecutionIdleOrAbort(scheduleHold.settled(), signal);
+              const goals = await goalHold.residencies(prepared.executions);
+              const roots = await prepared.residencies();
+              if (!goals || !roots || signal.aborted || draining) return undefined;
+              return [...roots, ...goals, ...scheduleHold.residencies()];
+            },
+            detach: async () => {
+              detached = true;
+              signal.removeEventListener('abort', cancel);
+              await prepared.detach();
+              // Domain holds stay closed until the lifecycle owner drains us.
+            },
+            cancel,
+          };
+        } catch (error) {
+          cancel();
+          if (signal.aborted) return undefined;
+          throw error;
+        }
+      },
       releaseConnection: (connectionId: string) => {
         for (const module of domainModules) module.releaseConnection?.(connectionId);
       },
diff --git a/packages/runtime-host/src/server/goal-coordinator.ts b/packages/runtime-host/src/server/goal-coordinator.ts
index 7104a83076..35f3c00d06 100644
--- a/packages/runtime-host/src/server/goal-coordinator.ts
+++ b/packages/runtime-host/src/server/goal-coordinator.ts
@@ -311,6 +311,51 @@ export class HostGoalCoordinator {
     }
   }
 
+  holdForHandoff():
+    | {
+        settled(): Promise<void>;
+        residencies(
+          executions: readonly { sessionId: string; turnId: string; runId: string }[],
+        ): Promise<readonly RuntimeHostResidency[] | undefined>;
+        release(): void;
+      }
+    | undefined {
+    if (this.#draining) return undefined;
+    const hold = this.continuation.holdForHandoff();
+    if (!hold) return undefined;
+    const settled = async () => {
+      await hold.settled();
+      await this.#flushGoalState();
+    };
+    return {
+      settled,
+      release: hold.release,
+      residencies: async (executions) => {
+        await settled();
+        if (this.#draining) return undefined;
+        for (const [sessionId] of this.#residencies) {
+          const authority = this.#authorityBySession.get(sessionId);
+          if (!authority) return undefined;
+          const current = authority.record.currentExecution;
+          const paused = executions.find((execution) => execution.sessionId === sessionId);
+          // An observed external turn is not a durable Goal execution. Its
+          // in-memory completion registration cannot be silently discarded.
+          if (
+            paused &&
+            (!current ||
+              current.execution.turnId !== paused.turnId ||
+              current.execution.runId !== paused.runId)
+          )
+            return undefined;
+          if (current && !paused) return undefined;
+          if (current && !this.matchesActive(sessionId, current.checkpoint, current.controlLease))
+            return undefined;
+        }
+        return [...this.#residencies.values()];
+      },
+    };
+  }
+
   beginDrain(): void {
     if (this.#draining) return;
     this.#draining = true;
diff --git a/packages/runtime-host/src/server/host-kernel.ts b/packages/runtime-host/src/server/host-kernel.ts
index ab407eed55..5576dcea07 100644
--- a/packages/runtime-host/src/server/host-kernel.ts
+++ b/packages/runtime-host/src/server/host-kernel.ts
@@ -146,11 +146,22 @@ export interface RuntimeHostComposition {
   readonly clientCapabilities?: ClientCapabilityService;
   readonly hostChanges?: HostChangeFeed;
   releaseConnection?(connectionId: string): void;
+  prepareHandoff?(
+    hostEpoch: string,
+    signal: AbortSignal,
+  ): Promise<RuntimeHostHandoffPreparation | undefined>;
   beginDrain(): void;
   recover(): Promise<void>;
   close(): Promise<void>;
 }
 
+export interface RuntimeHostHandoffPreparation {
+  seal(): Promise<boolean>;
+  residencies(): Promise<readonly RuntimeHostResidency[] | undefined>;
+  detach(): Promise<void>;
+  cancel(): void;
+}
+
 export type RuntimeHostCompositionFactory = (
   context: RuntimeHostCompositionContext,
 ) => Promise<RuntimeHostComposition>;
@@ -218,6 +229,7 @@ export class RuntimeHostKernel {
   #hasAcceptedConnection = false;
   #activeOperations = 0;
   #activeCommandOperations = 0;
+  #handoff: { abort: AbortController; commandsClosed: boolean; committing: boolean } | undefined;
   #retainedUntilProcessExit = false;
   #composition: RuntimeHostComposition | undefined;
   #compositionDrainBegun = false;
@@ -481,7 +493,7 @@ export class RuntimeHostKernel {
     authority: RuntimeHostConnectionAuthority,
   ): Promise<HostHandshakeResult> {
     const admittedState = await this.#readAdmissionState();
-    if (!admittedState) {
+    if (!admittedState || this.#handoff) {
       return {
         kind: 'draining',
         hostEpoch: this.hostEpoch,
@@ -523,7 +535,16 @@ export class RuntimeHostKernel {
       hello.generation !== undefined &&
       hello.generation !== this.#options.generation;
     if (generationMismatch && hello.takeover?.expectedHostEpoch === this.hostEpoch) {
-      if (authority.principalKind === 'local_owner' && this.#isTrueIdle(transport)) {
+      const residencyCount =
+        hello.activitySnapshotVersion === 2
+          ? this.#residencies.drainCount
+          : this.#residencies.activeCount;
+      if (
+        authority.principalKind === 'local_owner' &&
+        residencyCount === 0 &&
+        this.#hasNoObservedWork(transport)
+      ) {
+        this.#shutdownReason = 'retirement';
         this.#requestDrain();
         return {
           kind: 'draining',
@@ -553,8 +574,9 @@ export class RuntimeHostKernel {
           this.#lifecycle.kind === 'ephemeral' && this.#isSettledForReplacementAdvice()
             ? 'wait_for_idle_exit'
             : 'blocked_by_residency',
-        ...(generationMismatch && authority.principalKind === 'local_owner'
-          ? { activity: this.#activitySnapshot() }
+        ...(authority.principalKind === 'local_owner' &&
+        (generationMismatch || hello.activitySnapshotVersion === 2)
+          ? { activity: this.#activitySnapshot(hello.activitySnapshotVersion) }
           : {}),
       };
     }
@@ -565,6 +587,9 @@ export class RuntimeHostKernel {
     this.#cancelIdle();
     return {
       kind: 'accepted',
+      ...(hello.activitySnapshotVersion === 2 && this.#composition?.prepareHandoff
+        ? { cooperativeHandoff: true as const }
+        : {}),
       rootId: this.#options.owner.capability.rootId,
       hostEpoch: this.hostEpoch,
       connectionId: randomUUID(),
@@ -593,6 +618,12 @@ export class RuntimeHostKernel {
     frame: RequestFrame,
   ): Promise<ConnectionOperationLease | HostOperationErrorCode> {
     if (!(await this.#readAdmissionState())) return 'host_draining';
+    if (
+      this.#handoff &&
+      HOST_OPERATION_SPECS[frame.operation].mode === 'command' &&
+      (this.#handoff.commandsClosed || frame.operation !== 'turn.stop')
+    )
+      return 'host_draining';
     if (
       HOST_OPERATION_SPECS[frame.operation].availability !== 'bootstrap' &&
       this.#state !== 'ready'
@@ -664,14 +695,11 @@ export class RuntimeHostKernel {
   }
 
   #acquireResidency(label: string): RuntimeHostResidency {
-    const residency = this.#residencies.acquire(label);
+    const residency = this.#residencies.acquire(label, 'drain', () =>
+      this.#settleLifecycleAfterWork(),
+    );
     this.#cancelIdle();
-    return {
-      release: () => {
-        residency.release();
-        this.#settleLifecycleAfterWork();
-      },
-    };
+    return residency;
   }
 
   #retainUntilProcessExit(): void {
@@ -714,7 +742,7 @@ export class RuntimeHostKernel {
           ok: true,
           result: await this.#resourceCollector.snapshot(this.hostEpoch),
         }),
-        'host.upgrade.prepare': async (input) => {
+        'host.upgrade.prepare': async (input, context) => {
           if (input.expectedHostEpoch !== this.hostEpoch) {
             return {
               ok: false,
@@ -725,7 +753,12 @@ export class RuntimeHostKernel {
             };
           }
           if (!input.allowInterruptActiveTasks && this.#hasUpgradeBlockingActivity(1)) {
-            return { ok: true, result: { kind: 'active_tasks' } };
+            if (
+              !input.allowCooperativeHandoff ||
+              !(await this.#prepareCooperativeHandoff(context.inputClosedSignal))
+            ) {
+              return { ok: true, result: { kind: 'active_tasks' } };
+            }
           }
           this.#shutdownReason = 'retirement';
           this.#requestDrain();
@@ -867,12 +900,18 @@ export class RuntimeHostKernel {
     };
   }
 
-  #activitySnapshot(): HostActivitySnapshot {
+  #activitySnapshot(version?: 2): HostActivitySnapshot {
     return {
       connections: this.#acceptedTransports.size,
       activeOperations: this.#activeOperations,
       processUptimeSeconds: Math.max(0, Math.floor(process.uptime())),
       residencies: this.#residencies.snapshot(),
+      ...(version === 2
+        ? {
+            drainResidencies: this.#residencies.drainCount,
+            ...(this.#composition?.prepareHandoff ? { cooperativeHandoff: true } : {}),
+          }
+        : {}),
     };
   }
 
@@ -888,6 +927,62 @@ export class RuntimeHostKernel {
     return this.#residencies.drainCount > 0;
   }
 
+  async #prepareCooperativeHandoff(inputClosedSignal: AbortSignal | undefined): Promise<boolean> {
+    if (
+      !inputClosedSignal ||
+      inputClosedSignal.aborted ||
+      !this.#composition?.prepareHandoff ||
+      this.#handoff ||
+      this.#acceptedTransports.size > 1 ||
+      this.#activeCommandOperations > 1
+    )
+      return false;
+    const handoff = { abort: new AbortController(), commandsClosed: false, committing: false };
+    this.#handoff = handoff;
+    const cancelOnDisconnect = () => {
+      if (!handoff.committing) handoff.abort.abort();
+    };
+    inputClosedSignal.addEventListener('abort', cancelOnDisconnect, { once: true });
+    const timer = setTimeout(() => handoff.abort.abort(), 10_000);
+    let prepared: RuntimeHostHandoffPreparation | undefined;
+    try {
+      prepared = await this.#composition.prepareHandoff(this.hostEpoch, handoff.abort.signal);
+      if (!prepared || handoff.abort.signal.aborted || this.#activeCommandOperations !== 1)
+        return false;
+      handoff.commandsClosed = true;
+      if (!(await prepared.seal())) return false;
+      const residencies = await prepared.residencies();
+      if (
+        !residencies ||
+        handoff.abort.signal.aborted ||
+        !(await this.#hasLiveOwnerOrDrain()) ||
+        handoff.abort.signal.aborted ||
+        this.#handoff !== handoff ||
+        this.#acceptedTransports.size !== 1 ||
+        this.#activeCommandOperations !== 1 ||
+        this.#residencies.hasDrainResidenciesExcept(residencies)
+      )
+        return false;
+      // No await between the final exact-handle proof and closing all command
+      // admission. After this cut cancellation must not restart the old runs.
+      handoff.committing = true;
+      clearTimeout(timer);
+      await prepared.detach();
+      return true;
+    } finally {
+      clearTimeout(timer);
+      inputClosedSignal.removeEventListener('abort', cancelOnDisconnect);
+      if (handoff.committing) {
+        this.#shutdownReason = 'retirement';
+        this.#requestDrain();
+      } else {
+        handoff.abort.abort();
+        prepared?.cancel();
+      }
+      if (this.#handoff === handoff) this.#handoff = undefined;
+    }
+  }
+
   #beginCompositionDrain(): void {
     if (!this.#composition || this.#compositionDrainBegun) return;
     this.#compositionDrainBegun = true;
@@ -924,7 +1019,11 @@ export class RuntimeHostKernel {
     }, this.#lifecycle.idleGraceMs);
   }
 
-  #isTrueIdle(exceptHandshaking?: RuntimeHostMessageTransport): boolean {
+  #isTrueIdle(): boolean {
+    return this.#residencies.activeCount === 0 && this.#hasNoObservedWork();
+  }
+
+  #hasNoObservedWork(exceptHandshaking?: RuntimeHostMessageTransport): boolean {
     // A transport mid-handshake keeps the Host busy, except the one whose
     // admission is being decided right now: counting it would make every
     // true-idle takeover observe itself as activity.
@@ -936,8 +1035,7 @@ export class RuntimeHostKernel {
       this.#state === 'ready' &&
       this.#acceptedTransports.size === 0 &&
       handshaking === 0 &&
-      this.#activeOperations === 0 &&
-      this.#residencies.activeCount === 0
+      this.#activeOperations === 0
     );
   }
 
diff --git a/packages/runtime-host/src/server/host-residency-registry.ts b/packages/runtime-host/src/server/host-residency-registry.ts
index 069635b7c4..10d971f74d 100644
--- a/packages/runtime-host/src/server/host-residency-registry.ts
+++ b/packages/runtime-host/src/server/host-residency-registry.ts
@@ -50,7 +50,7 @@ export class HostResidencyRegistry {
     readonly resolve: () => void;
   }>();
   #activeCount = 0;
-  #drainCount = 0;
+  readonly #drainHandles = new Set<OperationResidency>();
 
   /** Residencies of either kind keep the process alive against idle exit. */
   get activeCount(): number {
@@ -59,25 +59,37 @@ export class HostResidencyRegistry {
 
   /** Only drain-kind residencies block maintenance probes and graceful close. */
   get drainCount(): number {
-    return this.#drainCount;
+    return this.#drainHandles.size;
   }
 
-  acquire(label: string, kind: HostResidencyKind = 'drain'): OperationResidency {
+  hasDrainResidenciesExcept(allowed: readonly OperationResidency[]): boolean {
+    const proven = new Set(allowed);
+    return [...this.#drainHandles].some((handle) => !proven.has(handle));
+  }
+
+  acquire(
+    label: string,
+    kind: HostResidencyKind = 'drain',
+    onRelease?: () => void,
+  ): OperationResidency {
     requireResidencyLabel(label);
     this.#activeCount += 1;
-    if (kind === 'drain') this.#drainCount += 1;
     const counts = this.#counts.get(label) ?? { total: 0, drain: 0 };
     counts.total += 1;
     if (kind === 'drain') counts.drain += 1;
     this.#counts.set(label, counts);
     let active = true;
-    return {
+    const handle: OperationResidency = {
       release: () => {
         if (!active) return;
         active = false;
+        this.#drainHandles.delete(handle);
         this.#release(label, kind);
+        onRelease?.();
       },
     };
+    if (kind === 'drain') this.#drainHandles.add(handle);
+    return handle;
   }
 
   snapshot(): readonly HostResidencySnapshot[] {
@@ -103,7 +115,6 @@ export class HostResidencyRegistry {
     counts.total -= 1;
     if (kind === 'drain') {
       counts.drain -= 1;
-      this.#drainCount -= 1;
     }
     this.#activeCount -= 1;
     if (counts.total === 0) this.#counts.delete(label);
diff --git a/packages/runtime-host/src/server/hosted-execution-admission-registry.ts b/packages/runtime-host/src/server/hosted-execution-admission-registry.ts
index 9403b305f9..5280d9918d 100644
--- a/packages/runtime-host/src/server/hosted-execution-admission-registry.ts
+++ b/packages/runtime-host/src/server/hosted-execution-admission-registry.ts
@@ -174,7 +174,9 @@ export class HostedExecutionAdmissionRegistry {
 
   waitForSettledAdmissions(): Promise<void> {
     return Promise.all(
-      [...this.#bySession.values()].map((value) => value.admissionSettled.promise),
+      [...this.#bySession.values()]
+        .filter((value) => value.kind === 'pending')
+        .map((value) => value.admissionSettled.promise),
     ).then(() => undefined);
   }
 }
diff --git a/packages/runtime-host/src/server/hosted-execution-recovery.ts b/packages/runtime-host/src/server/hosted-execution-recovery.ts
index 82133c7e9d..4398157964 100644
--- a/packages/runtime-host/src/server/hosted-execution-recovery.ts
+++ b/packages/runtime-host/src/server/hosted-execution-recovery.ts
@@ -18,6 +18,7 @@
  */
 
 import { isDeepStrictEqual } from 'node:util';
+import { readLogicalRuntimeExecution } from '@maka/core/runtime-logical-execution';
 import {
   runtimeInvocationOutcome,
   type RootExecutionDescriptor,
@@ -76,6 +77,12 @@ export async function prepareHostedExecutionRecovery(
     const pendingRecoveryClosures: RootTurnAdmission[] = [];
     for (const admission of admissions) {
       const run = runsById.get(admission.runId);
+      const logical =
+        run && (await readLogicalRuntimeExecution(input.stores.runtimeEventStore, admission, run));
+      if (logical?.pendingHandoff) {
+        replayAdmissions.push(admission);
+        rootReplayAdmissions.push(admission);
+      }
       const rootUserMessages = (
         messageIndex.userMessagesByTurnId.get(admission.turnId) ?? []
       ).filter((message) => message.id === admission.userMessageId);
@@ -85,7 +92,7 @@ export async function prepareHostedExecutionRecovery(
       const executionContract = recoveryExecutionContract(admission.execution);
       if (
         admission.execution.kind === 'scheduled_task' &&
-        (!run || runtimeInvocationOutcome(run) === undefined)
+        (!logical || runtimeInvocationOutcome(logical.tip) === undefined)
       ) {
         if (!input.assertScheduledTaskAdmission) {
           throw new RuntimeMessageAuthorityInvariantError(
diff --git a/packages/runtime-host/src/server/message-coordinator.ts b/packages/runtime-host/src/server/message-coordinator.ts
index 0bad3a0a4d..f82f6e896c 100644
--- a/packages/runtime-host/src/server/message-coordinator.ts
+++ b/packages/runtime-host/src/server/message-coordinator.ts
@@ -78,6 +78,7 @@ import { worstCaseFailedTurnSnapshot } from './canonical-turn-snapshot.js';
 import { worstCaseMessageQueueProjection } from './message-queue-capacity.js';
 import type { ConnectionContext, MessageOperationHandlerMap } from './operation-dispatcher.js';
 import { type SessionAdmissionLease, SessionAdmissionGate } from './session-admission-gate.js';
+import type { LogicalRuntimeExecution } from '@maka/core/runtime-logical-execution';
 
 type MessageOperationErrorCode =
   | 'host_draining'
@@ -228,6 +229,9 @@ export interface HostMessageRootPort {
 
 /** Existing durable facts used only to prove an earlier Host Epoch's submit disposition. */
 export interface HostMessageDurableProofReader {
+  readLogicalExecution(
+    identity: RuntimeMessageRunIdentity,
+  ): Promise<LogicalRuntimeExecution | undefined>;
   readRootTurnSourceMessageReceipt(
     sessionId: string,
     messageId: string,
@@ -339,7 +343,7 @@ interface SessionState {
   steering: LiveEntry[];
   inFlight: Map<string, LiveEntry>;
   followup: LiveEntry[];
-  reservedRoot?: RuntimeMessageRunIdentity;
+  reservedRoot?: RuntimeMessageRunIdentity & { expectedRunId: string };
   run?: BoundRun;
   transition?: TerminalTransition;
   stopFence?: {
@@ -654,13 +658,20 @@ export class HostMessageCoordinator implements RuntimeMessageAuthority {
   bindRun(identity: RuntimeMessageRunIdentity): RuntimeMessageRunOwner {
     const state = this.#state(identity.sessionId);
     const exactPreStartStop =
-      state.stopFence !== undefined && sameRun(state.stopFence.identity, identity);
+      state.stopFence !== undefined &&
+      state.reservedRoot !== undefined &&
+      sameRun(state.stopFence.identity, state.reservedRoot);
     if (state.phase !== 'open' && !exactPreStartStop) {
       throw new RuntimeMessageAuthorityInvariantError(
         'Message Run bound while admission was closed',
       );
     }
-    if (!state.reservedRoot || !sameRun(state.reservedRoot, identity) || state.run) {
+    if (
+      !state.reservedRoot ||
+      state.reservedRoot.turnId !== identity.turnId ||
+      state.reservedRoot.expectedRunId !== identity.runId ||
+      state.run
+    ) {
       throw new RuntimeMessageAuthorityInvariantError(
         `Message Run ${identity.runId} was not the exact reserved root identity`,
       );
@@ -687,10 +698,92 @@ export class HostMessageCoordinator implements RuntimeMessageAuthority {
         'Cannot reserve a root Turn during live ownership',
       );
     }
-    state.reservedRoot = { ...identity };
+    state.reservedRoot = { ...identity, expectedRunId: identity.runId };
     state.phase = 'open';
   }
 
+  /** Change physical ownership, not the logical queue generation or Stop identity. */
+  async advanceHandoffRun(
+    identity: RuntimeMessageRunIdentity,
+    successorRunId: string,
+    admission: SessionAdmissionLease,
+  ): Promise<void> {
+    await this.#sessionAdmission.runAdmitted(identity.sessionId, admission, async () => {
+      const logical = await this.#durableProof.readLogicalExecution(identity);
+      const state = this.#requireState(identity.sessionId);
+      if (
+        !logical?.pendingHandoff ||
+        logical.pendingHandoff.successorRunId !== successorRunId ||
+        !state.reservedRoot ||
+        !sameRun(state.reservedRoot, identity) ||
+        state.transition ||
+        (state.phase !== 'open' && !state.stopFence) ||
+        state.inFlight.size !== 0 ||
+        (state.run
+          ? !state.run.released || state.run.runId !== logical.tip.runId
+          : state.reservedRoot.expectedRunId !== identity.runId)
+      ) {
+        throw new RuntimeMessageAuthorityInvariantError(
+          'Physical handoff lacks a sealed released root owner',
+        );
+      }
+      state.run = undefined;
+      state.reservedRoot.expectedRunId = successorRunId;
+    });
+  }
+
+  async #readDetachableHandoff(
+    identity: RuntimeMessageRunIdentity,
+  ): Promise<SessionState | undefined> {
+    const logical = await this.#durableProof.readLogicalExecution(identity);
+    const state = this.#requireState(identity.sessionId);
+    if (state.stopFence || state.pendingInterrupts.size !== 0) return undefined;
+    if (
+      !logical?.pendingHandoff ||
+      !state.reservedRoot ||
+      !sameRun(state.reservedRoot, identity) ||
+      !state.run?.released ||
+      state.run.runId !== logical.tip.runId ||
+      state.inFlight.size !== 0 ||
+      state.transition
+    ) {
+      throw new RuntimeMessageAuthorityInvariantError(
+        'Handoff cannot detach unsettled Message ownership',
+      );
+    }
+    return state;
+  }
+
+  async handoffResidencies(
+    identity: RuntimeMessageRunIdentity,
+    admission: SessionAdmissionLease,
+  ): Promise<readonly RuntimeHostResidency[] | undefined> {
+    return this.#sessionAdmission.runAdmitted(identity.sessionId, admission, async () => {
+      const state = await this.#readDetachableHandoff(identity);
+      return state && allLiveEntries(state).map((entry) => entry.residency);
+    });
+  }
+
+  async detachHandoffRoot(
+    identity: RuntimeMessageRunIdentity,
+    admission: SessionAdmissionLease,
+  ): Promise<void> {
+    await this.#sessionAdmission.runAdmitted(identity.sessionId, admission, async () => {
+      const state = await this.#readDetachableHandoff(identity);
+      if (!state)
+        throw new RuntimeMessageAuthorityInvariantError(
+          'Stop took ownership before handoff detach',
+        );
+      // Confirmed admissions remain durable for the next Host. Only local leases
+      // and handles retire; do not write cancellation receipts or a queue fence.
+      this.#retractQueued(state);
+      state.run = undefined;
+      state.reservedRoot = undefined;
+      state.phase = 'closed';
+      this.#maybeReclaim(identity.sessionId, state);
+    });
+  }
+
   abandonRootReservation(identity: RuntimeMessageRunIdentity): void {
     const state = this.#requireState(identity.sessionId);
     if (!state.reservedRoot || !sameRun(state.reservedRoot, identity) || state.run) {
@@ -715,7 +808,8 @@ export class HostMessageCoordinator implements RuntimeMessageAuthority {
       !state.reservedRoot ||
       !sameRun(state.reservedRoot, identity) ||
       !run ||
-      !sameRun(run, identity) ||
+      run.turnId !== identity.turnId ||
+      run.runId !== state.reservedRoot.expectedRunId ||
       !run.released
     ) {
       throw new RuntimeMessageAuthorityInvariantError(
@@ -769,7 +863,7 @@ export class HostMessageCoordinator implements RuntimeMessageAuthority {
     this.#commitTransition(state);
     state.generation += 1;
     for (const entry of allLiveEntries(state)) entry.generation = state.generation;
-    state.reservedRoot = { ...identity };
+    state.reservedRoot = { ...identity, expectedRunId: identity.runId };
     state.phase = 'open';
     this.#mutated(state);
   }
@@ -832,6 +926,7 @@ export class HostMessageCoordinator implements RuntimeMessageAuthority {
       NonNullable<MarkMessagesHandedOffInput['provenSteeringMessages']>[number]
     > = [];
     const admissions = await this.#admissions.listMessageAdmissions(input.sessionId);
+    let logicalRunIds: readonly string[] | undefined;
     for (const messageId of new Set(input.messageIds)) {
       messageIds.add(messageId);
       provenRootMessages.push(await this.#readProvenRootMessage(input, messageId));
@@ -844,7 +939,17 @@ export class HostMessageCoordinator implements RuntimeMessageAuthority {
         input.sessionId,
         admission.messageId,
       );
-      if (proof?.event.turnId === input.turnId && proof.event.runId === input.runId) {
+      if (
+        proof?.event.turnId === input.turnId &&
+        proof.event.runId !== input.runId &&
+        !logicalRunIds
+      ) {
+        logicalRunIds = (await this.#durableProof.readLogicalExecution(input))?.runIds ?? [];
+      }
+      if (
+        proof?.event.turnId === input.turnId &&
+        (proof.event.runId === input.runId || logicalRunIds?.includes(proof.event.runId))
+      ) {
         messageIds.add(admission.messageId);
         provenSteeringMessages.push({
           messageId: admission.messageId,
diff --git a/packages/runtime-host/src/server/operation-dispatcher.ts b/packages/runtime-host/src/server/operation-dispatcher.ts
index cba2b5569d..bbde94a645 100644
--- a/packages/runtime-host/src/server/operation-dispatcher.ts
+++ b/packages/runtime-host/src/server/operation-dispatcher.ts
@@ -84,6 +84,8 @@ export interface ConnectionContext {
   credentialId?: string;
   credentialClientInstanceId?: string;
   clientInstanceId?: string;
+  /** EOF/teardown latch; dispatched operations opt in to cancellation. */
+  inputClosedSignal?: AbortSignal;
   turnAdmissionAuthorization?: RootTurnAdmissionAuthorization;
   acquireResidency(): OperationResidency;
 }
diff --git a/packages/runtime-host/src/server/root-turn-coordinator.ts b/packages/runtime-host/src/server/root-turn-coordinator.ts
index c8eb4958db..ca48342957 100644
--- a/packages/runtime-host/src/server/root-turn-coordinator.ts
+++ b/packages/runtime-host/src/server/root-turn-coordinator.ts
@@ -20,6 +20,7 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
 import type { BackendStopMode } from '@maka/core/backend-types';
+import { readLogicalRuntimeExecution } from '@maka/core/runtime-logical-execution';
 import type {
   RootExecutionDescriptor,
   RuntimeInvocationRecord,
@@ -166,8 +167,18 @@ interface ActiveRootTurn {
   startSettled: Deferred;
   done: Promise<void>;
   residency: RuntimeHostResidency;
-  stopRequested: boolean;
+  stopRequested: StopSessionInput | undefined;
   messageTransitionCommitted: boolean;
+  handoff?: { decision: ValueDeferred<'resume' | 'detach'>; arrived: Deferred };
+}
+
+/** Epoch-local attachment hold. The existing deployment transaction owns cutover. */
+export interface RootHandoffPreparation {
+  readonly executions: readonly HostedExecutionRef[];
+  seal(): Promise<boolean>;
+  residencies(): Promise<readonly RuntimeHostResidency[] | undefined>;
+  detach(): Promise<void>;
+  cancel(): void;
 }
 
 export type TurnStartOutcome = OperationOutcome<'turn.start'>;
@@ -316,6 +327,8 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
 
   readonly #executions = new HostedExecutionRegistry<ActiveRootTurn>();
   readonly #admissions: HostedExecutionAdmissionRegistry;
+  #handoffHold: Deferred | undefined;
+  #cancelHandoff: (() => void) | undefined;
   readonly #recoveryPlansBySession = new Map<string, HostedExecutionRecoveryPlan>();
   private readonly stores: ExecutionStoresWriter<'interactive'>;
   private readonly executionProjection: HostedExecutionProjectionReader;
@@ -393,6 +406,7 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
             });
           }
         } else {
+          if (plan.rootReplayAdmission === admission) continue;
           if (admission.execution.kind !== 'safe_boundary_continuation') {
             throw new Error(`Startup recovery left Turn ${admission.turnId} non-terminal`);
           }
@@ -402,7 +416,12 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
       const admission = plan.rootReplayAdmission;
       if (!admission) continue;
       // Session recovery may have materialized this Run after the replay plan was prepared.
-      if (await this.readRunIfPresent(sessionId, admission.runId)) continue;
+      const existingRun = await this.readRunIfPresent(sessionId, admission.runId);
+      const pendingHandoff =
+        existingRun &&
+        (await readLogicalRuntimeExecution(this.stores.runtimeEventStore, admission, existingRun))
+          ?.pendingHandoff;
+      if (existingRun && !pendingHandoff) continue;
       const input = activationInputForAdmission(admission);
       const disposition = await this.sessionAdmission.run(sessionId, async (lease) => {
         if (admission.execution.kind === 'safe_boundary_continuation') {
@@ -413,7 +432,7 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
           }
         }
         const continuation =
-          admission.execution.kind === 'safe_boundary_continuation'
+          admission.execution.kind === 'safe_boundary_continuation' && !pendingHandoff
             ? await this.reconstructAdmittedContinuation(admission)
             : undefined;
         if (continuation?.disposition === 'parked') {
@@ -459,6 +478,7 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
   }
 
   async close(): Promise<void> {
+    this.#cancelHandoff?.();
     this.beginDrain();
     await this.#admissions.waitForSettledAdmissions();
     const errors: unknown[] = [];
@@ -516,7 +536,9 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
         runId: active.runId,
       };
     }
-    return this.#admissions.has(sessionId) ? { kind: 'reserved' } : { kind: 'idle' };
+    return this.#handoffHold || this.#admissions.has(sessionId)
+      ? { kind: 'reserved' }
+      : { kind: 'idle' };
   }
 
   /** Returns the newest Host-admitted continuation descended from one root execution. */
@@ -561,6 +583,7 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
   }
 
   private reserveRootTurn(sessionId: string): RootTurnReservation | undefined {
+    if (this.#handoffHold) return undefined;
     return this.#admissions.reserve(sessionId);
   }
 
@@ -571,6 +594,7 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
   private takeParkedContinuationReservation(
     admission: RootTurnAdmission,
   ): RootTurnReservation | undefined {
+    if (this.#handoffHold) return undefined;
     return this.#admissions.takeParked(admission);
   }
 
@@ -594,6 +618,177 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
     this.#admissions.beginDrain();
   }
 
+  async prepareHandoff(
+    hostEpoch: string,
+    signal: AbortSignal,
+  ): Promise<RootHandoffPreparation | undefined> {
+    if (this.#handoffHold || this.#admissions.isDraining || signal.aborted) return undefined;
+    const hold = deferred();
+    this.#handoffHold = hold;
+    const held = new Map<
+      ActiveRootTurn,
+      {
+        request: NonNullable<ReturnType<SessionManager['requestRunHandoff']>>;
+        attachment: NonNullable<ActiveRootTurn['handoff']>;
+      }
+    >();
+    let sealed = false;
+    let detached = false;
+    const releaseHold = () => {
+      if (this.#handoffHold === hold) {
+        this.#handoffHold = undefined;
+        this.#cancelHandoff = undefined;
+      }
+      hold.resolve();
+      signal.removeEventListener('abort', cancel);
+    };
+    const cancel = () => {
+      if (detached) return;
+      sealed = false;
+      for (const [active, { request, attachment }] of held) {
+        request.cancel();
+        attachment.arrived.resolve();
+        attachment.decision.resolve('resume');
+        if (active.handoff === attachment) active.handoff = undefined;
+      }
+      releaseHold();
+    };
+    this.#cancelHandoff = cancel;
+    signal.addEventListener('abort', cancel, { once: true });
+    try {
+      await waitForHostedExecutionIdleOrAbort(this.#admissions.waitForSettledAdmissions(), signal);
+      // Natural completion can hand a queued follow-up to a fresh root while
+      // gates converge. Bound that convergence; never chase an endless queue.
+      for (let pass = 0; pass < 3; pass += 1) {
+        for (const [, active] of this.#executions.entries()) {
+          if (held.has(active)) continue;
+          await waitForHostedExecutionIdleOrAbort(active.startSettled.promise, signal);
+          if (this.#executions.get(active.sessionId) !== active) continue;
+          const request = this.manager.requestRunHandoff(
+            active.sessionId,
+            active.continuation?.runId ?? active.runId,
+            {
+              protocol: 'runtime_handoff_pause_v1',
+              hostEpoch,
+              handoffId: randomUUID(),
+              rootRunId: active.runId,
+              successorRunId: randomUUID(),
+              successorInvocationId: randomUUID(),
+              claimId: randomUUID(),
+            },
+            signal,
+          );
+          if (!request) {
+            cancel();
+            return undefined;
+          }
+          const attachment = {
+            decision: valueDeferred<'resume' | 'detach'>(),
+            arrived: deferred(),
+          };
+          active.handoff = attachment;
+          held.set(active, { request, attachment });
+        }
+        for (const [active, item] of held) {
+          if (await waitForAbortableValue(item.request.ready, signal)) continue;
+          const snapshot = await this.readCanonicalSnapshot(
+            active.sessionId,
+            active.turnId,
+            active.runId,
+          );
+          if (!isTerminalSnapshot(snapshot)) {
+            cancel();
+            return undefined;
+          }
+          item.attachment.decision.resolve('resume');
+          if (active.handoff === item.attachment) active.handoff = undefined;
+          await waitForHostedExecutionIdleOrAbort(active.done, signal);
+          held.delete(active);
+        }
+        if ([...this.#executions.entries()].every(([, active]) => held.has(active))) break;
+      }
+      if (
+        signal.aborted ||
+        [...this.#executions.entries()].some(([, active]) => !held.has(active))
+      ) {
+        cancel();
+        return undefined;
+      }
+      return {
+        executions: [...held.keys()].map(({ sessionId, turnId, runId }) => ({
+          sessionId,
+          turnId,
+          runId,
+        })),
+        seal: async () => {
+          if (signal.aborted || this.#handoffHold !== hold || detached) return false;
+          if (sealed) return true;
+          for (const [active, { request }] of held) {
+            if (this.#executions.get(active.sessionId) !== active || !request.commit()) {
+              cancel();
+              return false;
+            }
+          }
+          try {
+            const results = await Promise.all(
+              [...held.values()].map(({ request }) => request.sealed),
+            );
+            sealed = !signal.aborted && this.#handoffHold === hold && results.every(Boolean);
+            if (sealed) {
+              await Promise.all(
+                [...held].map(([active, { attachment }]) =>
+                  Promise.race([
+                    attachment.arrived.promise,
+                    active.done.then(() => {
+                      throw new Error('Sealed execution ended before its attachment handoff');
+                    }),
+                  ]),
+                ),
+              );
+            }
+          } catch (error) {
+            cancel();
+            throw error;
+          }
+          if (!sealed) cancel();
+          return sealed;
+        },
+        residencies: async () => {
+          if (!sealed || signal.aborted || this.#handoffHold !== hold || detached) return undefined;
+          const residencies: RuntimeHostResidency[] = [];
+          for (const [active, { attachment }] of held) {
+            if (
+              this.#executions.get(active.sessionId) !== active ||
+              active.handoff !== attachment ||
+              active.stopRequested
+            )
+              return undefined;
+            const messages = await this.sessionAdmission.run(active.sessionId, (lease) =>
+              this.messages.handoffResidencies(active, lease),
+            );
+            if (!messages) return undefined;
+            residencies.push(active.residency, ...messages);
+          }
+          return residencies;
+        },
+        detach: async () => {
+          if (!sealed || signal.aborted || this.#handoffHold !== hold || detached) {
+            throw new Error('Cannot detach a handoff without all durable seals');
+          }
+          detached = true;
+          for (const { attachment } of held.values()) attachment.decision.resolve('detach');
+          await Promise.all([...held.keys()].map((active) => active.done));
+          releaseHold();
+        },
+        cancel,
+      };
+    } catch (error) {
+      cancel();
+      if (signal.aborted) return undefined;
+      throw error;
+    }
+  }
+
   async runExclusiveSessionOperation<T>(
     input: {
       readonly sessionId: string;
@@ -616,7 +811,7 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
       }
       const active = this.#executions.get(sessionId);
       const pending = this.#admissions.get(sessionId);
-      const whenIdle = active?.done ?? pending?.whenIdle.promise;
+      const whenIdle = active?.done ?? pending?.whenIdle.promise ?? this.#handoffHold?.promise;
       if (whenIdle) {
         await waitForHostedExecutionIdleOrAbort(whenIdle, abortSignal);
       }
@@ -676,6 +871,7 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
         reason: 'Runtime Host execution authority is draining.',
       };
     }
+    if (this.#handoffHold) return { kind: 'busy', whenIdle: this.#handoffHold.promise };
     const active = this.#executions.get(sessionId);
     if (active) {
       return {
@@ -942,7 +1138,9 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
 
   whenIdle(sessionId: string): Promise<void> | undefined {
     return (
-      this.#executions.get(sessionId)?.done ?? this.#admissions.get(sessionId)?.whenIdle.promise
+      this.#executions.get(sessionId)?.done ??
+      this.#admissions.get(sessionId)?.whenIdle.promise ??
+      this.#handoffHold?.promise
     );
   }
 
@@ -2108,9 +2306,13 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
       input.sessionId,
       fence.retracted.map((message) => message.messageId),
     );
-    await this.interactions.claimRunClosure(input, 'turn_stopped', admission);
+    await this.interactions.claimRunClosure(
+      { ...input, runId: active.continuation?.runId ?? active.runId },
+      'turn_stopped',
+      admission,
+    );
     const shouldDeliverStop = !active.stopRequested;
-    active.stopRequested = true;
+    active.stopRequested = stopInput;
     return {
       active,
       deliverStop: () =>
@@ -2147,7 +2349,7 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
           input.sessionId,
           fence.retracted.map((message) => message.messageId),
         );
-        active.stopRequested = true;
+        active.stopRequested ??= { source: 'stop_button' };
         return { kind: 'await_terminal', active };
       }
       return { kind: 'complete', outcome: { ok: true, result: snapshot } };
@@ -2176,9 +2378,13 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
       input.sessionId,
       fence.retracted.map((message) => message.messageId),
     );
-    await this.interactions.claimRunClosure(input, 'turn_stopped', admissionLease);
+    await this.interactions.claimRunClosure(
+      { ...input, runId: active.continuation?.runId ?? active.runId },
+      'turn_stopped',
+      admissionLease,
+    );
     const shouldRequestStop = !active.stopRequested;
-    active.stopRequested = true;
+    active.stopRequested ??= { source: 'stop_button' };
     return shouldRequestStop
       ? { kind: 'request_stop', active }
       : { kind: 'await_terminal', active };
@@ -2238,7 +2444,25 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
         return { kind: 'await_start', active };
       }
       if (active) return completedStart(sessionBusy('Session already has an active root Turn'));
-      throw new Error('Admitted non-terminal Turn has no active Runtime Host execution');
+      const logical = await readLogicalRuntimeExecution(
+        this.stores.runtimeEventStore,
+        admission,
+        existingRun,
+      );
+      if (!logical?.pendingHandoff) {
+        throw new Error('Admitted non-terminal Turn has no active Runtime Host execution');
+      }
+      const plan = await this.manager.planAuthoritativeSafeBoundaryContinuation(input.sessionId, {
+        sourceRunId: logical.tip.runId,
+        purpose: 'handoff',
+      });
+      if (!plan.continuation) {
+        this.parkContinuationAdmission(admission);
+        return completedStart(
+          operationUnavailable(`Sealed handoff cannot resume: ${plan.rejectionReasons.join(', ')}`),
+        );
+      }
+      continuation = plan.continuation;
     }
 
     const active = this.#executions.get(input.sessionId);
@@ -2275,6 +2499,9 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
     try {
       this.messages.reserveRootTurn(messageIdentity);
       messageReserved = true;
+      if (continuation?.handoffRootRunId !== undefined) {
+        await this.messages.advanceHandoffRun(messageIdentity, continuation.runId, admissionLease);
+      }
       await this.continuity.holdTerminalPublication(
         input.sessionId,
         input.turnId,
@@ -2308,7 +2535,7 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
       startSettled,
       done: Promise.resolve(),
       residency,
-      stopRequested: false,
+      stopRequested: undefined,
       messageTransitionCommitted: false,
     };
     if (replacing && this.#executions.get(input.sessionId) !== replacing) {
@@ -2401,6 +2628,7 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
     startSettled: Deferred,
   ): Promise<void> {
     let terminalTransitionStarted = false;
+    let detached = false;
     try {
       const messageOrigin = hostedExecutionMessageOrigin(active.descriptor);
       const onRunStarted = async (): Promise<void> => {
@@ -2408,49 +2636,89 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
         await this.continuity.refreshCanonical(input.sessionId);
         startSettled.resolve();
       };
-      const stream = active.execution
-        ? active.execution.start({
-            runId: active.runId,
-            userMessageId: active.userMessageId,
-            onRunStarted: async () => {
-              await onRunStarted();
-              await active.execution?.onReady?.();
-            },
+      let stream = active.continuation
+        ? this.manager.resumeSafeBoundaryContinuation(active.continuation, {
+            onRunStarted,
+            stopBeforeDispatch: () => active.stopRequested,
           })
-        : active.descriptor.kind === 'context_compact'
-          ? this.manager.compactSession(input.sessionId, {
-              turnId: input.turnId,
-              hostedRoot: {
-                runId: active.runId,
-                onRunStarted,
+        : active.execution
+          ? active.execution.start({
+              runId: active.runId,
+              userMessageId: active.userMessageId,
+              onRunStarted: async () => {
+                await onRunStarted();
+                await active.execution?.onReady?.();
               },
             })
-          : active.continuation
-            ? this.manager.resumeSafeBoundaryContinuation(active.continuation, {
-                onRunStarted,
+          : active.descriptor.kind === 'context_compact'
+            ? this.manager.compactSession(input.sessionId, {
+                turnId: input.turnId,
+                hostedRoot: {
+                  runId: active.runId,
+                  onRunStarted,
+                },
               })
-            : this.startRootMessageTurn(
-                input,
-                active,
-                normalizeMessageContent(requireRootMessageContent(input)),
-                messageOrigin,
-                onRunStarted,
-              );
-      for await (const event of stream) {
-        if (active.execution?.onEvent) {
-          try {
-            active.execution.onEvent(event);
-          } catch {
-            // Presentation observers do not participate in execution authority.
+            : active.continuation
+              ? this.manager.resumeSafeBoundaryContinuation(active.continuation, {
+                  onRunStarted,
+                })
+              : this.startRootMessageTurn(
+                  input,
+                  active,
+                  normalizeMessageContent(requireRootMessageContent(input)),
+                  messageOrigin,
+                  onRunStarted,
+                );
+      for (;;) {
+        for await (const event of stream) {
+          if (active.execution?.onEvent) {
+            try {
+              active.execution.onEvent(event);
+            } catch {
+              // Presentation observers do not participate in execution authority.
+            }
+          }
+          if (isRuntimeSessionForwardedEvent(event)) {
+            await this.continuity.acceptRuntimeEvent(input.sessionId, active.runId, event);
+          } else if (isInteractionAnswerAck(event)) {
+            await this.continuity.refreshCanonical(input.sessionId);
+          } else if (event.type === 'user_question_request' || event.type === 'form_request') {
+            this.continuity.enqueueCanonicalRefresh(input.sessionId);
           }
         }
-        if (isRuntimeSessionForwardedEvent(event)) {
-          await this.continuity.acceptRuntimeEvent(input.sessionId, active.runId, event);
-        } else if (isInteractionAnswerAck(event)) {
-          await this.continuity.refreshCanonical(input.sessionId);
-        } else if (event.type === 'user_question_request' || event.type === 'form_request') {
-          this.continuity.enqueueCanonicalRefresh(input.sessionId);
+        const logical = await readLogicalRuntimeExecution(this.stores.runtimeEventStore, active);
+        if (!logical?.pendingHandoff) break;
+        const handoff = active.handoff;
+        handoff?.arrived.resolve();
+        if (handoff && (await handoff.decision.promise) === 'detach') {
+          await this.sessionAdmission.run(input.sessionId, (lease) =>
+            this.messages.detachHandoffRoot(active, lease),
+          );
+          detached = true;
+          return;
         }
+        await this.sessionAdmission.run(input.sessionId, async (lease) => {
+          if (this.#executions.get(input.sessionId) !== active) {
+            throw new RuntimeMessageAuthorityInvariantError(
+              'Sealed handoff lost its original root owner',
+            );
+          }
+          const plan = await this.manager.planAuthoritativeSafeBoundaryContinuation(
+            input.sessionId,
+            {
+              sourceRunId: logical.tip.runId,
+              purpose: 'handoff',
+            },
+          );
+          if (!plan.continuation)
+            throw new Error(`Sealed handoff cannot resume: ${plan.rejectionReasons.join(', ')}`);
+          await this.messages.advanceHandoffRun(active, plan.continuation.runId, lease);
+          active.continuation = plan.continuation;
+        });
+        stream = this.manager.resumeSafeBoundaryContinuation(active.continuation!, {
+          onRunStarted,
+          stopBeforeDispatch: () => active.stopRequested,
+        });
       }
       const snapshot = await this.readCanonicalSnapshot(
         input.sessionId,
@@ -2499,7 +2767,7 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
               ((!active.stopRequested &&
                 snapshot.status === 'failed' &&
                 isContainableRunFailure(error)) ||
-                (active.stopRequested &&
+                (Boolean(active.stopRequested) &&
                   snapshot.status === 'cancelled' &&
                   isStoppedInteractionAdmission(error)));
           }
@@ -2518,31 +2786,36 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
       if (!isShutdownCancelledInteractionAdmission(commandFailure)) this.requestHostDrain();
       throw commandFailure;
     } finally {
-      this.observeExecutionCompletion(active, {
-        kind: 'authority_error',
-        execution: active,
-        reason: 'Runtime root Turn ended without a canonical completion.',
-      });
-      await active.observationSettled?.catch(() => this.requestHostDrain());
-      let releaseRootOwnership = active.messageTransitionCommitted;
-      if (!active.messageTransitionCommitted) {
-        try {
-          this.messages.abandonRootReservation({
-            sessionId: input.sessionId,
-            turnId: active.turnId,
-            runId: active.runId,
-          });
-          releaseRootOwnership = true;
-        } catch {
-          this.requestHostDrain();
-        }
-      }
-      if (releaseRootOwnership) {
+      if (detached) {
         this.#executions.release(active);
         active.residency.release();
+      } else {
+        this.observeExecutionCompletion(active, {
+          kind: 'authority_error',
+          execution: active,
+          reason: 'Runtime root Turn ended without a canonical completion.',
+        });
+        await active.observationSettled?.catch(() => this.requestHostDrain());
+        let releaseRootOwnership = active.messageTransitionCommitted;
+        if (!active.messageTransitionCommitted) {
+          try {
+            this.messages.abandonRootReservation({
+              sessionId: input.sessionId,
+              turnId: active.turnId,
+              runId: active.runId,
+            });
+            releaseRootOwnership = true;
+          } catch {
+            this.requestHostDrain();
+          }
+        }
+        if (releaseRootOwnership) {
+          this.#executions.release(active);
+          active.residency.release();
+        }
+        active.completion.resolve(active.observedCompletion!);
+        this.#executions.publish(active);
       }
-      active.completion.resolve(active.observedCompletion!);
-      this.#executions.publish(active);
     }
   }
 
@@ -2597,7 +2870,10 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
         turnId: active.turnId,
         runId: active.runId,
       };
-      await this.interactions.assertTerminalFence(identity, lease);
+      await this.interactions.assertTerminalFence(
+        { ...identity, runId: active.continuation?.runId ?? active.runId },
+        lease,
+      );
       const batch = this.messages.beginTerminalTransition(identity);
       await this.continuity.publishTerminalProjection(
         sessionId,
@@ -2785,6 +3061,14 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
   }
 }
 
+async function waitForAbortableValue<T>(value: Promise<T>, signal: AbortSignal): Promise<T> {
+  await waitForHostedExecutionIdleOrAbort(
+    value.then(() => undefined),
+    signal,
+  );
+  return value;
+}
+
 class HostedRootAdmissionGateError extends Error {
   readonly name = 'HostedRootAdmissionGateError';
 
diff --git a/packages/runtime-host/src/server/scheduled-task-coordinator.ts b/packages/runtime-host/src/server/scheduled-task-coordinator.ts
index 2bbdbf7d51..e4e45cf83f 100644
--- a/packages/runtime-host/src/server/scheduled-task-coordinator.ts
+++ b/packages/runtime-host/src/server/scheduled-task-coordinator.ts
@@ -157,6 +157,7 @@ export class HostScheduledTaskCoordinator implements ScheduledTaskToolAuthority
   #prepared = false;
   #started = false;
   #draining = false;
+  #handoffHeld = false;
   #closed = false;
   readonly #retiringSessions = new Set<string>();
 
@@ -255,6 +256,37 @@ export class HostScheduledTaskCoordinator implements ScheduledTaskToolAuthority
     void this.#refresh().catch((error: unknown) => this.#fatal(error));
   }
 
+  holdForHandoff():
+    | {
+        settled(): Promise<void>;
+        residencies(): readonly RuntimeHostResidency[];
+        release(): void;
+      }
+    | undefined {
+    if (this.#draining || this.#handoffHeld) return undefined;
+    this.#handoffHeld = true;
+    this.#stopTimer();
+    let released = false;
+    return {
+      settled: async () => {
+        // An admitted native effect or Agent fire finishes normally. No new
+        // fire may start while the handoff waits for this lane.
+        for (;;) {
+          const lane = this.#lane;
+          await lane;
+          if (lane === this.#lane) return;
+        }
+      },
+      residencies: () => (this.#residency ? [this.#residency] : []),
+      release: () => {
+        if (released) return;
+        released = true;
+        this.#handoffHeld = false;
+        if (!this.#draining) void this.#refresh().catch((error: unknown) => this.#fatal(error));
+      },
+    };
+  }
+
   beginDrain(): void {
     if (this.#draining) return;
     this.#draining = true;
@@ -530,12 +562,14 @@ export class HostScheduledTaskCoordinator implements ScheduledTaskToolAuthority
 
   async #refresh(): Promise<void> {
     await this.#exclusive(async () => {
+      if (this.#handoffHeld || this.#draining) return;
       for (const claim of await this.#store.listPendingFires()) {
+        if (this.#handoffHeld || this.#draining) break;
         if (claim.nativeState === 'waiting_for_provider') {
           await this.#fulfill(claim, true);
         }
       }
-      while (!this.#draining) {
+      while (!this.#draining && !this.#handoffHeld) {
         const scan = await this.#store.claimNextDue(this.#now());
         for (const expired of scan.expired) this.#publish('updated', expired.id);
         const claim = scan.claim;
@@ -812,7 +846,7 @@ export class HostScheduledTaskCoordinator implements ScheduledTaskToolAuthority
   async #refreshSchedule(): Promise<void> {
     this.#stopTimer();
     await this.#refreshResidency();
-    if (!this.#started || this.#draining) return;
+    if (!this.#started || this.#draining || this.#handoffHeld) return;
     const [tasks, claims] = await Promise.all([this.#store.list(), this.#store.listPendingFires()]);
     const next = tasks
       .filter((task) => task.status === 'active' && task.nextFireAt !== null)
@@ -821,6 +855,7 @@ export class HostScheduledTaskCoordinator implements ScheduledTaskToolAuthority
         return earliest === null || deadline < earliest ? deadline : earliest;
       }, null);
     const waitingForProvider = claims.some((claim) => claim.nativeState === 'waiting_for_provider');
+    if (this.#draining || this.#handoffHeld) return;
     if (next === null && !waitingForProvider) return;
     const nextTaskDelay =
       next === null
diff --git a/packages/runtime-host/src/server/session-transcript-reader.ts b/packages/runtime-host/src/server/session-transcript-reader.ts
index cc51d9bd4a..236e693f86 100644
--- a/packages/runtime-host/src/server/session-transcript-reader.ts
+++ b/packages/runtime-host/src/server/session-transcript-reader.ts
@@ -18,6 +18,9 @@
  */
 
 import type { RuntimeEvent } from '@maka/core/runtime-event';
+import type { RuntimeInvocationRecord } from '@maka/core/runtime-invocation';
+import { runtimeHandoffPause } from '@maka/core/runtime-handoff';
+import { readLogicalRuntimeExecution } from '@maka/core/runtime-logical-execution';
 import type { StoredMessage } from '@maka/core/session';
 import {
   affectsRuntimeEventStoredMessageProjection,
@@ -60,14 +63,55 @@ export function createSessionTranscriptReader(input: {
     readActiveOverlay: async (sessionId, rootTurn) => {
       if (!rootTurn || isTerminalTurn(rootTurn)) return [];
 
-      const invocations = await input.stores.runtimeEventStore.listSessionInvocations(sessionId);
-      const events = await readActiveProjectionEvents(input.stores, sessionId, rootTurn.runId);
+      const store = input.stores.runtimeEventStore;
+      const root = await store.readRunInvocation(sessionId, rootTurn.runId);
+      if (!root) return [];
+      const budget = { events: 0, bytes: 0 };
+      const scanned = new Map<string, RuntimeEvent[]>();
+      const invocations = new Map<string, RuntimeInvocationRecord>([[root.runId, root]]);
+      const readEvents = async (runId: string): Promise<RuntimeEvent[]> => {
+        const cached = scanned.get(runId);
+        if (cached) return cached;
+        const events = await readActiveRuntimeEvents(input.stores, sessionId, runId, budget);
+        scanned.set(runId, events);
+        return events;
+      };
+      let runIds: readonly string[] = [root.runId];
+      if (root.terminalEvent && runtimeHandoffPause(root.terminalEvent)) {
+        const logical = await readLogicalRuntimeExecution(
+          {
+            ...store,
+            readRunInvocation: async (id, runId) => {
+              const run = await store.readRunInvocation(id, runId);
+              if (run) invocations.set(runId, run);
+              return run;
+            },
+            // Authenticate only after the same bounded scan used for presentation.
+            // Sealed prefixes cannot grow between this check and digest verification.
+            readImmutableRuntimeEvents: async (_id, runId) =>
+              (await readEvents(runId)).filter((event) => !event.partial),
+            readImmutableRuntimePrefix: async (prefix) => {
+              await readEvents(prefix.runId);
+              return store.readImmutableRuntimePrefix(prefix);
+            },
+          },
+          { sessionId, turnId: rootTurn.turnId, runId: rootTurn.runId },
+          root,
+        );
+        if (!logical) return [];
+        runIds = logical.runIds;
+      }
+      const events: RuntimeEvent[] = [];
+      for (const runId of runIds)
+        events.push(
+          ...(await readEvents(runId)).filter(affectsRuntimeEventStoredMessageProjection),
+        );
       const canonicalPermissionOutcomes = await readCanonicalPermissionOutcomes(
         events,
         input.canonicalPermissionOutcomes,
       );
       const projected = projectRuntimeEventsToStoredMessages(activePresentationEvents(events), {
-        invocations: invocations.filter((invocation) => invocation.runId === rootTurn.runId),
+        invocations: runIds.map((runId) => invocations.get(runId)!),
         canonicalPermissionOutcomes,
       });
       if (projected.diagnostics.some(isHardRuntimeEventReadModelDiagnostic)) {
@@ -175,14 +219,13 @@ function activePresentationEvents(events: readonly RuntimeEvent[]): RuntimeEvent
   return presented;
 }
 
-async function readActiveProjectionEvents(
+async function readActiveRuntimeEvents(
   stores: ExecutionStoresWriter<'interactive'>,
   sessionId: string,
   runId: string,
+  budget: { events: number; bytes: number },
 ): Promise<RuntimeEvent[]> {
   const events: RuntimeEvent[] = [];
-  let retainedEvents = 0;
-  let retainedBytes = 0;
   const result = await stores.runtimeEventStore.scanRuntimeEvents(
     sessionId,
     runId,
@@ -195,18 +238,17 @@ async function readActiveProjectionEvents(
       maxPartialBytes: ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES,
     },
     (batch) => {
-      const relevant = batch.filter(affectsRuntimeEventStoredMessageProjection);
-      for (const event of relevant) {
-        retainedEvents += 1;
-        retainedBytes += Buffer.byteLength(JSON.stringify(event), 'utf8');
-        if (retainedEvents > ACTIVE_TRANSCRIPT_SOURCE_MAX_EVENTS) {
+      for (const event of batch) {
+        budget.events += 1;
+        budget.bytes += Buffer.byteLength(JSON.stringify(event), 'utf8');
+        if (budget.events > ACTIVE_TRANSCRIPT_SOURCE_MAX_EVENTS) {
           throw new Error('Active RuntimeEvent transcript exceeds its event limit');
         }
-        if (retainedBytes > ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES) {
+        if (budget.bytes > ACTIVE_TRANSCRIPT_OVERLAY_MAX_BYTES) {
           throw new Error('Active RuntimeEvent transcript exceeds its byte limit');
         }
       }
-      events.push(...relevant);
+      events.push(...batch);
     },
   );
   if (result.status === 'limit_exceeded') {
diff --git a/packages/runtime/src/__tests__/ai-sdk-backend.test.ts b/packages/runtime/src/__tests__/ai-sdk-backend.test.ts
index 3de3d01097..127a1c358f 100644
--- a/packages/runtime/src/__tests__/ai-sdk-backend.test.ts
+++ b/packages/runtime/src/__tests__/ai-sdk-backend.test.ts
@@ -18,6 +18,7 @@
  */
 
 import assert from 'node:assert/strict';
+import { RunHandoffGate } from '../run-handoff-gate.js';
 import type { ModelProjectionTransition } from '@maka/core/model-projection-transition';
 import { Buffer } from 'node:buffer';
 import { createHash } from 'node:crypto';
@@ -5799,6 +5800,125 @@ describe('AiSdkBackend model history', () => {
     assert.equal(usage?.type === 'token_usage' ? usage.total : undefined, 2);
   });
 
+  for (const decision of ['cancel', 'commit', 'stop'] as const) {
+    test(`cooperative handoff ${decision} waits for the settled tool and gates the next request`, {
+      timeout: 5_000,
+    }, async () => {
+      const loop = countingToolLoopModel();
+      const durable = durableTurnHarness('turn-1', 'hi');
+      const toolEntered = makeGate();
+      const finishTool = makeGate();
+      const gate = new RunHandoffGate();
+      const request = gate.request(new AbortController().signal);
+      let reached = false;
+      void request.ready.then((ready) => {
+        reached = ready;
+      });
+      let effects = 0;
+      const backend = createTestAiSdkBackend({
+        sessionId: 'session-1',
+        header: header(),
+        appendMessage: async () => {},
+        connection: connection(),
+        apiKey: 'sk-test',
+        modelId: 'mock-model-id',
+        modelFactory: () => loop.model,
+        tools: [
+          {
+            name: 'Read',
+            description: 'count effects',
+            parameters: z.object({ path: z.string() }),
+            impl: async () => {
+              toolEntered.release();
+              await finishTool.promise;
+              effects += 1;
+              return { ok: true };
+            },
+          },
+        ],
+        loadTurnRuntimeEvents: durable.loadTurnRuntimeEvents,
+        newId: idGenerator(),
+        now: monotonicClock(),
+      });
+      const events: SessionEvent[] = [];
+      const running = (async () => {
+        for await (const event of backend.send(
+          durable.input({
+            maxSteps: 2,
+            handoffBoundary: (signal, remainingSteps) => {
+              assert.equal(remainingSteps, 1);
+              assert.equal(
+                events.some((event) => event.type === 'tool_result'),
+                true,
+              );
+              return gate.reachBoundary(signal);
+            },
+          }),
+        )) {
+          durable.record(event);
+          events.push(event);
+        }
+      })();
+      await toolEntered.promise;
+      assert.equal(reached, false);
+      assert.equal(effects, 0);
+      finishTool.release();
+      assert.equal(await request.ready, true);
+      assert.equal(loop.callCount(), 1);
+      assert.equal(effects, 1);
+      if (decision === 'commit') assert.equal(request.commit(), true);
+      else if (decision === 'cancel') request.cancel();
+      else await backend.stop('user_stop');
+      await running;
+      assert.equal(loop.callCount(), decision === 'cancel' ? 2 : 1);
+      assert.equal(effects, decision === 'cancel' ? 2 : 1);
+      assert.equal(
+        events.some((event) => event.type === 'complete'),
+        decision !== 'commit',
+      );
+      assert.equal(
+        events.some((event) => event.type === 'abort'),
+        decision === 'stop',
+      );
+      if (decision === 'commit')
+        assert.equal(
+          events.some((event) => event.type === 'token_usage'),
+          true,
+        );
+    });
+  }
+
+  test('a natural final answer does not enter the handoff gate', async () => {
+    let boundaries = 0;
+    const backend = createTestAiSdkBackend({
+      sessionId: 'session-1',
+      header: header(),
+      appendMessage: async () => {},
+      connection: connection(),
+      apiKey: 'sk-test',
+      modelId: 'mock-model-id',
+      modelFactory: () => textCompletionModel('done'),
+      tools: [],
+      newId: idGenerator(),
+      now: monotonicClock(),
+    });
+    const events: SessionEvent[] = [];
+    for await (const event of backend.send({
+      turnId: 'turn-1',
+      text: 'hi',
+      handoffBoundary: async () => {
+        boundaries += 1;
+        return 'pause';
+      },
+    }))
+      events.push(event);
+    assert.equal(boundaries, 0);
+    assert.equal(
+      events.some((event) => event.type === 'complete'),
+      true,
+    );
+  });
+
   test('aborting during post-stream persistence wins over step-limit completion', async () => {
     const loop = countingToolLoopModel();
     const gate = makeGate();
diff --git a/packages/runtime/src/__tests__/goal-continuation.test.ts b/packages/runtime/src/__tests__/goal-continuation.test.ts
index bbd77c7f1e..c4bf6ad923 100644
--- a/packages/runtime/src/__tests__/goal-continuation.test.ts
+++ b/packages/runtime/src/__tests__/goal-continuation.test.ts
@@ -185,6 +185,39 @@ function setup(opts?: {
   };
 }
 
+test('handoff hold finishes Goal accounting without admitting a successor; release resumes it', async () => {
+  const { manager, coordinator, admitted } = setup();
+  manager.create(SESSION, 'finish the work');
+  const hold = coordinator.holdForHandoff();
+  assert.ok(hold);
+  assert.equal(coordinator.holdForHandoff(), undefined);
+  await settleExternal(coordinator, SESSION, { kind: 'completed', turnId: 'external' });
+  await hold.settled();
+  assert.equal(admitted.length, 0);
+  assert.equal(manager.get(SESSION)?.status, 'active');
+  hold.release();
+  hold.release();
+  await waitFor(() => admitted.length === 1);
+  await coordinator.close();
+});
+
+test('handoff hold removes waiting timers and cancellation restores the same Goal', async () => {
+  const { manager, coordinator, scheduler, admitted } = setup({ evaluations: [{ waiting: true }] });
+  manager.create(SESSION, 'wait for the work');
+  await settleExternal(coordinator, SESSION, { kind: 'completed', turnId: 'external' });
+  await waitFor(() => scheduler.pendingDelays().length === 1);
+  const before = manager.get(SESSION);
+  const hold = coordinator.holdForHandoff();
+  assert.ok(hold);
+  await hold.settled();
+  assert.deepEqual(scheduler.pendingDelays(), []);
+  assert.equal(admitted.length, 0);
+  assert.deepEqual(manager.get(SESSION), before);
+  hold.release();
+  await waitFor(() => scheduler.pendingDelays().length === 1);
+  await coordinator.close();
+});
+
 async function waitFor(condition: () => boolean, message = 'condition was not met'): Promise<void> {
   await pollFor(condition, { timeoutMs: 1_000, message });
 }
diff --git a/packages/runtime/src/__tests__/run-handoff-gate.test.ts b/packages/runtime/src/__tests__/run-handoff-gate.test.ts
new file mode 100644
index 0000000000..28ef2cbbd0
--- /dev/null
+++ b/packages/runtime/src/__tests__/run-handoff-gate.test.ts
@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { RunHandoffGate } from '../run-handoff-gate.js';
+
+test('handoff cancellation leaves the same execution free to continue', async () => {
+  for (const atBoundary of [false, true]) {
+    const gate = new RunHandoffGate();
+    const cancel = new AbortController();
+    const request = gate.request(cancel.signal);
+    assert.equal(request.commit(), false, 'a request is not a checkpoint');
+    const boundary = atBoundary ? gate.reachBoundary(new AbortController().signal) : undefined;
+    if (atBoundary) assert.equal(await request.ready, true);
+    cancel.abort();
+    assert.equal(request.commit(), false);
+    assert.equal(await request.ready, atBoundary);
+    if (boundary) assert.equal(await boundary, 'continue');
+    assert.equal(await gate.reachBoundary(new AbortController().signal), 'continue');
+  }
+});
+
+test('only the held boundary can commit and stale cancellation cannot release a later reservation', async () => {
+  const gate = new RunHandoffGate();
+  const first = gate.request(new AbortController().signal);
+  const firstBoundary = gate.reachBoundary(new AbortController().signal);
+  assert.equal(await first.ready, true);
+  first.cancel();
+  assert.equal(await firstBoundary, 'continue');
+  const second = gate.request(new AbortController().signal);
+  const secondBoundary = gate.reachBoundary(new AbortController().signal);
+  assert.equal(await second.ready, true);
+  first.cancel();
+  assert.equal(first.commit(), false);
+  assert.equal(second.commit(), true);
+  second.cancel();
+  assert.equal(await secondBoundary, 'pause');
+  assert.equal(second.commit(), false);
+});
+
+test('user Stop releases a paused boundary and natural completion resolves a pending request', async () => {
+  const gate = new RunHandoffGate();
+  const execution = new AbortController();
+  const request = gate.request(new AbortController().signal);
+  const boundary = gate.reachBoundary(execution.signal);
+  assert.equal(await request.ready, true);
+  execution.abort();
+  assert.equal(await boundary, 'continue');
+  assert.equal(request.commit(), false);
+  const pending = gate.request(new AbortController().signal);
+  gate.close();
+  assert.equal(await pending.ready, false);
+  assert.equal(await gate.request(new AbortController().signal).ready, false);
+});
diff --git a/packages/runtime/src/__tests__/runtime-event-read-model.test.ts b/packages/runtime/src/__tests__/runtime-event-read-model.test.ts
index c47760680f..8a38f4c50e 100644
--- a/packages/runtime/src/__tests__/runtime-event-read-model.test.ts
+++ b/packages/runtime/src/__tests__/runtime-event-read-model.test.ts
@@ -1852,6 +1852,18 @@ type ActionCoverageSamples = {
 };
 
 const ACTION_COVERAGE_SAMPLES: ActionCoverageSamples = {
+  handoffPause: {
+    action: {
+      protocol: 'runtime_handoff_pause_v1',
+      handoffId: 'handoff',
+      hostEpoch: 'host',
+      remainingSteps: null,
+      rootRunId: 'root',
+      successorRunId: 'next',
+      successorInvocationId: 'next',
+      claimId: 'claim',
+    },
+  },
   // `stateDelta` is an open record, so only named shapes are claimed and this
   // entry covers the field, not its contents. A new key inside a state delta is
   // out of reach of any contract keyed on the action surface.
diff --git a/packages/runtime/src/__tests__/runtime-handoff.test.ts b/packages/runtime/src/__tests__/runtime-handoff.test.ts
new file mode 100644
index 0000000000..b0945a8cb5
--- /dev/null
+++ b/packages/runtime/src/__tests__/runtime-handoff.test.ts
@@ -0,0 +1,252 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { test } from 'node:test';
+import { deferred } from '@maka/core/test-only/async-primitives';
+import type { BackendSendInput } from '@maka/core/backend-types';
+import type { SessionEvent } from '@maka/core/events';
+import { runtimeHandoffPause } from '@maka/core/runtime-handoff';
+import { readLogicalRuntimeExecution } from '@maka/core/runtime-logical-execution';
+import { createSessionStore } from '@maka/storage/session-store';
+import { createSqliteAgentRunStore } from '@maka/storage/agent-run-store';
+import { createSqliteRuntimeStore } from '@maka/storage/sqlite-runtime-store';
+import { openInteractivePlanStoreForWrite } from '@maka/storage/plan-authority';
+import { resolveStorageRoot, tryAcquireInteractiveRootOwner } from '@maka/storage/root-authority';
+import { RuntimeKernel } from '../runtime-kernel.js';
+import { BackendRegistry, SessionManager } from '../session-manager.js';
+import { FakeBackend } from '../test-only/fake-backend.js';
+import { prepareConversationRuntimeLedgerCopy } from '../conversation-copy.js';
+
+for (const decision of ['commit', 'cancel', 'stop', 'write_failure'] as const) {
+  test(`Runtime-owned handoff ${decision} preserves canonical logical outcome`, {
+    timeout: 10_000,
+  }, async () => {
+    const root = await mkdtemp(join(tmpdir(), 'maka-runtime-handoff-'));
+    const owner = await tryAcquireInteractiveRootOwner(
+      await resolveStorageRoot({ path: root, kind: 'interactive' }),
+    );
+    assert.ok(owner);
+    const store = createSessionStore(root);
+    const runStore = createSqliteAgentRunStore(root);
+    const planStore = await openInteractivePlanStoreForWrite(owner.lease);
+    const runtimeEventStore = createSqliteRuntimeStore(join(root, 'runtime.sqlite'));
+    const entered = deferred<void>();
+    const reachBoundary = deferred<void>();
+    const releaseStream = deferred<void>();
+    const executionAbort = new AbortController();
+    let backendDispatches = 0;
+    const backends = new BackendRegistry();
+    backends.register(
+      'ai-sdk',
+      (ctx) =>
+        new (class extends FakeBackend {
+          override async *send(input: BackendSendInput): AsyncIterable<SessionEvent> {
+            backendDispatches += 1;
+            if (!input.continuation) {
+              entered.resolve();
+              await reachBoundary.promise;
+              const result = await input.handoffBoundary!(executionAbort.signal, 2);
+              await releaseStream.promise;
+              if (result === 'pause' && !executionAbort.signal.aborted) return;
+            }
+            if (input.continuation) assert.equal(input.maxSteps, 2);
+            yield {
+              type: 'complete',
+              id: `complete-${backendDispatches}`,
+              turnId: input.turnId,
+              ts: Date.now(),
+              stopReason: executionAbort.signal.aborted ? 'user_stop' : 'end_turn',
+            };
+          }
+          override async stop(): Promise<void> {
+            executionAbort.abort();
+          }
+        })({ sessionId: ctx.sessionId, header: ctx.header, store: ctx.store }),
+    );
+    let id = 0;
+    const deps = {
+      store,
+      runStore,
+      runtimeEventStore,
+      planStore,
+      backends,
+      safeBoundaryResumeEnabled: true,
+      toolBoundaryProtocol: 't1_after_preflight_v1' as const,
+      inspectContinuationSafety: async () => ({
+        workspaceIdentity: 'workspace-1',
+        backgroundOperationsSettled: true,
+        availableToolNames: [] as string[],
+      }),
+      newId: () => `id-${++id}`,
+      now: Date.now,
+    };
+    const kernel = new RuntimeKernel(deps);
+    const manager = new SessionManager({ ...deps, runtimeKernel: kernel });
+    const session = await manager.createSession({
+      cwd: root,
+      llmConnectionSlug: 'fake',
+      model: 'fake-model',
+      permissionMode: 'ask',
+      name: 'handoff',
+    });
+    try {
+      await planStore.submitProposal({
+        sessionId: session.id,
+        turnId: 'proposal-turn',
+        title: 'work',
+        steps: [{ id: 'step-1', title: 'finish', description: 'finish the logical task' }],
+      });
+      const proposal = (await planStore.readState(session.id)).proposals[0]!;
+      await planStore.approveProposal({
+        sessionId: session.id,
+        proposalId: proposal.proposalId,
+        expectedRevision: proposal.revision,
+      });
+      const events: SessionEvent[] = [];
+      const running = (async () => {
+        for await (const event of manager.sendMessage(
+          session.id,
+          {
+            turnId: 'logical-turn',
+            text: 'continue work',
+            origin: { kind: 'goal', goalId: 'goal-1' },
+          },
+          { runId: 'original-run', durability: 'required' },
+        ))
+          events.push(event);
+      })();
+      void running.catch(() => {});
+      await entered.promise;
+      const pause = {
+        protocol: 'runtime_handoff_pause_v1' as const,
+        handoffId: 'handoff',
+        hostEpoch: 'host-1',
+        rootRunId: 'original-run',
+        successorRunId: 'successor-run',
+        successorInvocationId: 'successor-run',
+        claimId: 'exact-handoff-claim',
+      };
+      const request = kernel.requestRunHandoff(
+        session.id,
+        'original-run',
+        pause,
+        new AbortController().signal,
+      );
+      assert.ok(request);
+      reachBoundary.resolve();
+      assert.equal(await request.ready, true);
+      assert.equal(
+        events.some((event) => event.type === 'complete'),
+        false,
+      );
+      if (decision === 'write_failure') {
+        const append = runtimeEventStore.appendRuntimeEvent.bind(runtimeEventStore);
+        runtimeEventStore.appendRuntimeEvent = async (sessionId, runId, event, options) => {
+          if (event.actions?.handoffPause) throw new Error('pause durability failed');
+          return append(sessionId, runId, event, options);
+        };
+      }
+      if (decision === 'cancel') request.cancel();
+      else assert.equal(request.commit(), true);
+      const stopped =
+        decision === 'stop' ? kernel.stopSession(session.id, { source: 'stop_button' }) : undefined;
+      releaseStream.resolve();
+      if (decision === 'write_failure') {
+        await assert.rejects(running, /pause durability failed|finalization failed/);
+        await assert.rejects(request.sealed, /pause durability failed/);
+        return;
+      }
+      await stopped;
+      await running;
+      assert.equal(await request.sealed, decision === 'commit');
+      const source = await runtimeEventStore.readRunInvocation(session.id, 'original-run');
+      assert.ok(source?.terminalEvent);
+      if (decision !== 'commit') {
+        assert.equal(source.terminalEvent.status, decision === 'stop' ? 'aborted' : 'completed');
+        assert.equal(runtimeHandoffPause(source.terminalEvent), undefined);
+        return;
+      }
+      assert.deepEqual(runtimeHandoffPause(source.terminalEvent), { ...pause, remainingSteps: 2 });
+      assert.equal(source.terminalEvent.status, undefined);
+      assert.equal(
+        events.some((event) => event.type === 'complete' || event.type === 'error'),
+        false,
+      );
+      await assert.rejects(
+        prepareConversationRuntimeLedgerCopy({
+          sourceSessionId: session.id,
+          sourceEvents: await runtimeEventStore.readRuntimeEvents(session.id, 'original-run'),
+          copiedMessages: await store.readMessages(session.id),
+          runStore,
+          runtimeEventStore,
+        }),
+        { code: 'branch_runtime_fact_rewrite_unsupported' },
+      );
+      await manager.recoverInterruptedSessions();
+      assert.equal((await planStore.readState(session.id)).executions[0]?.status, 'active');
+      assert.deepEqual(
+        (await runtimeEventStore.readRunInvocation(session.id, 'original-run'))?.terminalEvent,
+        source.terminalEvent,
+      );
+      const plan = await manager.planAuthoritativeSafeBoundaryContinuation(session.id, {
+        sourceRunId: 'original-run',
+        purpose: 'handoff',
+      });
+      assert.ok(plan.continuation, JSON.stringify(plan));
+      assert.equal(plan.continuation.turnId, 'logical-turn');
+      assert.equal(plan.continuation.runId, 'successor-run');
+      assert.equal(
+        (
+          await manager.planAuthoritativeSafeBoundaryContinuation(session.id, {
+            sourceRunId: 'original-run',
+          })
+        ).disposition,
+        'park',
+      );
+      for await (const event of manager.resumeSafeBoundaryContinuation(plan.continuation))
+        events.push(event);
+      const logical = await readLogicalRuntimeExecution(runtimeEventStore, {
+        sessionId: session.id,
+        turnId: 'logical-turn',
+        runId: 'original-run',
+      });
+      assert.equal(backendDispatches, 2);
+      assert.equal(logical?.tip.runId, 'successor-run');
+      assert.deepEqual(logical?.tip.opening.root, { kind: 'goal', goalId: 'goal-1' });
+      assert.equal(logical?.tip.terminalEvent?.status, 'completed');
+      assert.equal(events.filter((event) => event.type === 'complete').length, 1);
+      await manager.recoverInterruptedSessions();
+      assert.equal((await planStore.readState(session.id)).executions[0]?.status, 'interrupted');
+    } finally {
+      reachBoundary.resolve();
+      releaseStream.resolve();
+      await kernel.disposeBackend(session.id).catch(() => {});
+      runtimeEventStore.close();
+      planStore.close();
+      await runStore.close?.();
+      await store.close?.();
+      await owner.close();
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+}
diff --git a/packages/runtime/src/__tests__/session-manager.test.ts b/packages/runtime/src/__tests__/session-manager.test.ts
index b059a7e8af..30e157520b 100644
--- a/packages/runtime/src/__tests__/session-manager.test.ts
+++ b/packages/runtime/src/__tests__/session-manager.test.ts
@@ -4640,11 +4640,10 @@ describe('SessionManager permission mode updates', () => {
     assert.strictEqual(run?.opening.configuration.workspaceIdentity, undefined);
   });
 
-  test('does not inspect continuation safety on normal turns while resume is disabled', async () => {
+  test('records handoff workspace identity even while manual resume is disabled', async () => {
     const store = new MemorySessionStore();
     const runStore = new MemoryAgentRunStore();
     const backends = new BackendRegistry();
-    let inspectionCalls = 0;
     backends.register('ai-sdk', (ctx) => new FinalTextTestBackend(ctx));
     const manager = new SessionManager({
       store,
@@ -4652,9 +4651,8 @@ describe('SessionManager permission mode updates', () => {
       runtimeEventStore: runStore,
       backends,
       inspectContinuationSafety: async () => {
-        inspectionCalls += 1;
         return {
-          workspaceIdentity: 'workspace-should-not-be-read',
+          workspaceIdentity: 'workspace-for-handoff',
           backgroundOperationsSettled: true,
           availableToolNames: [],
         };
@@ -4671,9 +4669,12 @@ describe('SessionManager permission mode updates', () => {
       }),
     );
 
-    assert.strictEqual(inspectionCalls, 0);
     const [run] = await runStore.listSessionInvocations(session.id);
-    assert.strictEqual(run?.opening.configuration.workspaceIdentity, undefined);
+    assert.strictEqual(run?.opening.configuration.workspaceIdentity, 'workspace-for-handoff');
+    const plan = await manager.planAuthoritativeSafeBoundaryContinuation(session.id, {
+      sourceRunId: run!.runId,
+    });
+    assert.deepEqual(plan.rejectionReasons, ['resume_feature_disabled']);
   });
 
   test('declares the T1 protocol for an AiSdk run when the host wires the durable boundary', async () => {
diff --git a/packages/runtime/src/agent-run.ts b/packages/runtime/src/agent-run.ts
index ff919edf1d..aa03983fae 100644
--- a/packages/runtime/src/agent-run.ts
+++ b/packages/runtime/src/agent-run.ts
@@ -26,6 +26,9 @@ import type {
   ToolBoundaryProtocol,
 } from '@maka/core/runtime-event';
 import type { RuntimeEventStore } from '@maka/core/runtime-event-store';
+import { isRuntimeHandoffPause, type RuntimeHandoffIntent } from '@maka/core/runtime-handoff';
+import { RunHandoffGate, type RunHandoffRequest } from './run-handoff-gate.js';
+import { preserveHandoffOpening } from './runtime-resume.js';
 import type { RunCompositionSnapshot } from '@maka/core/run-composition';
 import { decodeRunCompositionSnapshot } from '@maka/core/run-composition';
 import { DurableStoreWriteError, RunSealedError } from '@maka/core/runtime-event-store';
@@ -145,7 +148,7 @@ export interface AgentRunInput {
   header: SessionHeader;
   userInput: UserMessageInput;
   /** Internal lineage for runtime-owned continuations; never accepted by live turn input. */
-  runLineage?: Pick<AgentRunLineage, 'parentRunId'>;
+  runLineage?: AgentRunLineage;
   rootExecutionKind?: 'context_compact';
   runId?: string;
   userMessageId?: string | null;
@@ -159,6 +162,8 @@ export interface AgentRunInput {
   continuationFailpoint?: (point: RuntimeContinuationFailpoint) => Promise<void>;
   /** Exact target opening fact already committed inside the durable continuation claim. */
   claimedOpening?: RuntimeEventInvocationOpenedContent;
+  /** Authenticated source authority is not part of provider-visible replay. */
+  handoffSourceOpening?: RuntimeEventInvocationOpenedContent;
   /** The moment that claim was taken; the target invocation opens at it. */
   claimedOpenedAt?: number;
   /** Commits the claimed continuation provider-call T1 after Run creation. */
@@ -217,6 +222,12 @@ export interface AgentRunContinuationBeginResult {
 const RUNTIME_PARTIAL_FLUSH_INTERVAL_MS = 80;
 const RUNTIME_PARTIAL_BATCH_MAX_BYTES = 8 * 1024;
 
+export interface AgentRunHandoffRequest extends RunHandoffRequest {
+  readonly sealed: Promise<boolean>;
+  /** Hypothetical seal for read-only replay validation while the live gate is held. */
+  preview(): RuntimeEvent;
... 1818 lines suppressed ...


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@maka.apache.org
For additional commands, e-mail: commits-help@maka.apache.org