fix(editor): a render no longer restarts a failed runtime load (#757)

The lazy-runtime contract (#353) says a non-terminal failure waits for
the next explicit intent and that there are no background retries. But
_renderBody calls ensure() on every repaint while a surface waits for
the editor or onboarding runtime, and to the loader that call was
indistinguishable from an intent. Surfaces the core opens without the
runtime - the kiosk size dialog after a 3 s hold, the floor import
wizard on an empty plan, a dialog a warm remount revives - therefore
turned one failure into a loop: the loader's own state change, the
toast and its expiry, every hass tick repainted, started a new cycle
and showed a new toast every ~3.5 s. A wall tablet whose old hashed
chunks answer 404 after an integration update sat in that loop forever.

EditorRuntimeLoader.ensure takes an intent: the render calls it as
'reconcile'. A reconcile starts the first cycle a surface needs, but
after a non-terminal failure it returns false without loading until an
explicit ensure() - a tab, an opener, _requestMode, "Add space" - has
started a new cycle. Explicit calls, the terminal fingerprint failure,
ready and an in-flight cycle behave as before, for every loader
instance. The card's render lines stay line-neutral.

smoke_lazy_editor_chunk gains the three surfaces offline through their
real paths (a 3 s touch hold on a kiosk card, an empty plan pushed by
the server, General settings revived by a remount): one cycle, one
notice and an idle loader over 8 s, then the Plan tab and "Add space"
heal. On dev: 4 requests / 3 notices, 6 / 2 and 3 / 2. The loader unit
test pins reconcile versus intent; the mutant
render-reconcile-restarts-editor-runtime-cycle is guarded by the smoke.

Issue: #757
User-Visible: yes
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018qZfe7YS4rqEMKoVeS3GKd

test/editor-runtime-loader.test.mjs

@@ -187,6 +187,58 @@ test('network failure re-arms the loader for the next explicit intent (#353 AC1)
   assert.equal(failures.length, 2);
 });
 
+test('a render reconcile never starts another cycle after a network failure (#757 AC3)', async () => {
+  let cycles = 0;
+  let online = false;
+  const failures = [];
+  const loader = new EditorRuntimeLoader({
+    expectedFingerprint: 'same',
+    load: async (attempt) => {
+      if (attempt === 0) cycles++;
+      if (!online) throw new Error('net::ERR_FAILED');
+      return { fingerprint: 'same', create: () => 'runtime' };
+    },
+    install: () => {},
+    failed: (error, info) => failures.push(info.terminal),
+  });
+
+  assert.equal(await loader.ensure('reconcile'), false, 'a surface waiting for the runtime starts the first cycle');
+  assert.equal(cycles, 1);
+  assert.equal(loader.state, 'idle', 'the failure stays non-terminal');
+  for (let render = 0; render < 5; render++) assert.equal(await loader.ensure('reconcile'), false);
+  online = true;
+  assert.equal(await loader.ensure('reconcile'), false, 'a render after the network is back is still not an intent');
+  assert.equal(cycles, 1, 'no render started a cycle of its own');
+  assert.deepEqual(failures, [false], 'one failure, one notice');
+
+  online = false;
+  assert.equal(await loader.ensure(), false, 'an explicit intent starts a fresh cycle');
+  assert.equal(cycles, 2);
+  assert.equal(await loader.ensure('reconcile'), false, 'and its failure waits for the next intent again');
+  assert.equal(cycles, 2);
+
+  online = true;
+  const explicit = loader.ensure();
+  assert.equal(loader.ensure('reconcile'), explicit, 'a render joins the explicit cycle in flight');
+  assert.equal(await explicit, true);
+  assert.equal(cycles, 3);
+  assert.equal(await loader.ensure('reconcile'), true, 'ready answers a render too');
+});
+
+test('a render reconcile after a terminal failure stays terminal (#757 AC3)', async () => {
+  let loads = 0;
+  const loader = new EditorRuntimeLoader({
+    expectedFingerprint: 'entry',
+    load: async () => { loads++; return { fingerprint: 'other', create: () => 'foreign' }; },
+    install: () => {},
+  });
+  assert.equal(await loader.ensure('reconcile'), false);
+  assert.equal(loader.state, 'failed');
+  assert.equal(await loader.ensure('reconcile'), false);
+  assert.equal(await loader.ensure(), false);
+  assert.equal(loads, 2, 'one cycle of two attempts, never another import');
+});
+
 test('fingerprint mismatch on either attempt is terminal (#353 AC2)', async () => {
   const attempts = [];
   const failures = [];