fix(runtime-host): refuse a retired fake-backend session with the product reason

Dropping the `fake` registration left activation dispatching off a durable
header value with no factory behind it, so a session or Automation persisted by
an older build failed its next turn with `No backend factory registered for
kind="fake"`. The Desktop composer does gate these rows — `sendBlocked` reads a
destructive `sessionHealthNotice`, which `projectSessionSendOutcome` raises for
`fake_backend` — but that is a renderer gate, not an authority: `maka run`
resumes an existing session through a readiness check that only inspects the
connection catalog, and a persisted Automation template still accepts
`execution.backend: 'fake'`.

Register an explicit refusal where the test backend used to be. It throws the
canonical `NO_REAL_CONNECTION:fake_backend` error, which `parseNoRealConnectionError`
already turns into the copy both surfaces show for these rows: the task came
from the retired local simulation, add a real model and start a new one.

Rewriting the durable header to `ai-sdk` on the read path was the alternative
and is worse: it destroys the fact that drives that copy, and leaves a session
that looks runnable while its `llmConnectionSlug` still points at nothing, so
the failure would resurface later and less specifically.

Generated-by: Claude Code

Author: Astro-Han

packages/runtime-host/src/__tests__/execution-composition.test.ts

@@ -1,4 +1,5 @@
 import assert from 'node:assert/strict';
+import { parseNoRealConnectionError } from '@maka/core/connection-error-copy';
 import { createRequire } from 'node:module';
 import { mkdir, mkdtemp, rm, stat, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
@@ -378,6 +379,45 @@ test('production composition commits automatic titles through Host-owned Session
   });
 });
 
+test('a legacy fake-backend session is refused with the product reason, not a registry error', async () => {
+  await withCompositionRoot(async ({ root, owner }) => {
+    const { composition, manager } = await createCapturedExecutionComposition(owner);
+    try {
+      // Written by an older build: this one never produces `fake`, but the
+      // durable header survives and activation dispatches straight off it.
+      const legacy = await manager.createSession({
+        cwd: root,
+        backend: 'fake',
+        llmConnectionSlug: 'fake',
+        model: 'fake-model',
+        permissionMode: 'ask',
+      });
+      const failure = await composition.handlers['turn.start'](
+        {
+          sessionId: legacy.id,
+          turnId: 'turn-legacy-fake',
+          content: { text: 'resume a retired local simulation' },
+        },
+        {
+          hostEpoch: 'execution-composition-test',
+          connectionId: 'legacy-fake-client',
+          surface: 'tui',
+          principal: 'local_os_user',
+          acquireResidency: () => ({ release() {} }),
+        },
+      ).then(
+        (result) => result,
+        (error: unknown) => error,
+      );
+      const message = failure instanceof Error ? failure.message : JSON.stringify(failure);
+      assert.doesNotMatch(message, /No backend factory registered/);
+      assert.equal(parseNoRealConnectionError(message).reason, 'fake_backend');
+    } finally {
+      await composition.close();
+    }
+  });
+});
+
 test('production composition orphans ownerless ShellRuns before serving Resource queries', async () => {
   await withCompositionRoot(async ({ root, owner }) => {
     const stores = await openInteractiveExecutionStoresForWrite(owner.lease);

packages/runtime-host/src/server/execution-composition.ts

@@ -1,4 +1,8 @@
 import { createHash, randomUUID } from 'node:crypto';
+import {
+  describeChatConfigurationReason,
+  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';
@@ -285,6 +289,18 @@ export async function createExecutionRuntimeHostComposition(
     });
     await stores.messageReceiptStore.beginHostEpoch(context.hostEpoch);
     const backends = new BackendRegistry();
+    // `fake` is a retired backend kind: this build never writes it, but a
+    // session or Automation persisted by an older one still can, and activation
+    // dispatches straight off that durable value. Registering an explicit
+    // refusal — rather than the test backend, or a read-path rewrite of the
+    // durable header — is what turns "no factory for kind=fake" into the
+    // product's existing answer for these rows: this task came from the retired
+    // local simulation, configure a real model and start a new one.
+    backends.register('fake', () => {
+      throw new Error(
+        `${NO_REAL_CONNECTION_CODE}:fake_backend: ${describeChatConfigurationReason('fake_backend')}`,
+      );
+    });
     const runtimePolicyActivation = new RuntimePolicyActivationGate();
     const runtimePolicy = new HostRuntimePolicyCoordinator(
       runtimePolicyStores,