fix(gui): CI activation order + review-bot findings

The session-title snapshot exposed a real activation race: ui-trajectory
and ui-question register into conversation-declared slots but only
injected 'slots', so nothing ordered their applies after ui-conversation's
— register() into the undeclared slot threw and the entry FAILED. Both now
inject 'conversation' as an ordering edge (documented as such; specs stub
the service where the bench declares the slot itself).

Review-bot findings, all three applied: the module loader's load sink
cross-checks the handoff id against the arriving row (a mis-stamped bundle
can no longer register under another entry's identity); the default
execute seam removes the inline script node right after its synchronous
execution (repeated HMR rebuilds no longer accumulate dead nodes); a
throwing onRebuilt subscriber is contained per-listener and routed to
onError instead of escaping the fs.watchFile callback.

packages/client/ui-question/src/client/index.ts

@@ -14,8 +14,13 @@ import { QuestionComposer } from './QuestionComposer.tsx'
 export { PendingQuestion } from './contract/slots.ts'
 export type { QuestionAnswer, QuestionComposerProps, QuestionWait } from './contract/slots.ts'
 
-/** Required services (cordis fiber inject — the loader passes the whole export surface as an object plugin). */
-export const inject = ['slots']
+/**
+ * Required services (cordis fiber inject). 'conversation' is an ordering
+ * edge, not a call dependency: the 'conversation.composer' chain slot is
+ * declared by ui-conversation's apply, and register() into an undeclared
+ * slot throws — service waiting orders this apply after the declaring one.
+ */
+export const inject = ['slots', 'conversation']
 
 /** Chain routing: claim the composer while a question wait is pending (pure — owner props only). */
 function selectQuestion({ interactions }: ComposerChainProps): QuestionWait | null {

packages/client/ui-question/tests/browser-plugin.spec.ts

@@ -23,17 +23,23 @@ async function bench() {
     { name: 'root', children: { 'conversation.composer': { kind: 'chain', scope: 'session' } } } as never,
     () => null,
   )
+  // 'conversation' inject is an ordering edge (the declaring plugin provides
+  // it after declaring the chain); the bench declares the chain itself.
+  ctx.provide('conversation', {})
   return { ctx, slots }
 }
 
 describe('apply', () => {
   it('declares the services it binds', () => {
-    expect(inject).toEqual(['slots'])
+    expect(inject).toEqual(['slots', 'conversation'])
   })
 
   it('fails loud when no live entry has declared the composer slot', async () => {
     const ctx = new Context()
     await ctx.plugin(SlotsService).await()
+    // Satisfy the ordering inject without declaring the chain: apply must
+    // then hit the undeclared-slot throw, not sit waiting on the service.
+    ctx.provide('conversation', {})
     await expect(ctx.plugin({ inject: [...inject], apply }))
       .rejects.toThrow(/slot "conversation.composer" is not declared/)
   })