fix(client,host): late duplicate-provider conflicts roll back wholesale and fail loud

Holes declared after two flow providers activated left the loser throwing
out of the slot flush with partial occupancy. deferRegistration gains an
onFailure channel (late failures unsubscribe, then hand over instead of
throwing through the flush); the native flow's pair rolls back wholesale
and re-raises on the global channel the boot's fail-loud handler owns.
Duplicate rows of the SAME package stay silently idempotent (the component
identity guard skips an occupied hole).

packages/host/directory-picker-native/src/client/index.ts

@@ -29,13 +29,21 @@ export function apply(ctx: ClientContext): void {
   ctx.effect(() => {
     // Constructing the pair can throw halfway (a declared hole already
     // occupied registers synchronously): roll the earlier deferral back so
-    // no live subscription outlives the failed fiber.
+    // no live subscription outlives the failed fiber. A conflict surfacing
+    // from a LATER ledger flush (holes declared after two flow providers
+    // activated) rolls the whole pair back the same way and re-raises on
+    // the global channel the boot's fail-loud handler owns — never a throw
+    // through the slot flush, never partial occupancy from this package.
     const deferred: ReturnType<typeof deferRegistration>[] = []
+    const lateConflict = (error: unknown): void => {
+      for (const entry of deferred) entry.dispose()
+      queueMicrotask(() => { throw error instanceof Error ? error : new Error(String(error)) })
+    }
     try {
       deferred.push(deferRegistration(ctx.slots, 'conversation.hero.workspace.directoryFlow', NativeDirectoryFlow, () =>
-        ctx.slots.register({ name: 'conversation.hero.workspace.directoryFlow', inject: injected }, NativeDirectoryFlow)))
+        ctx.slots.register({ name: 'conversation.hero.workspace.directoryFlow', inject: injected }, NativeDirectoryFlow), lateConflict))
       deferred.push(deferRegistration(ctx.slots, 'sidebar.workspaces.directoryFlow', NativeDirectoryFlow, () =>
-        ctx.slots.register({ name: 'sidebar.workspaces.directoryFlow', inject: injected }, NativeDirectoryFlow)))
+        ctx.slots.register({ name: 'sidebar.workspaces.directoryFlow', inject: injected }, NativeDirectoryFlow), lateConflict))
     } catch (error) {
       for (const entry of deferred) entry.dispose()
       throw error

packages/host/directory-picker-native/tests/client-flow.spec.tsx

@@ -56,6 +56,34 @@ describe('directory-picker-native client half', () => {
     for (const hole of HOLES) expect(after.slots.entries(hole)).toHaveLength(1)
   })
 
+  it('rolls back wholesale and reports loudly when a rival provider wins after deferred activation', async () => {
+    const b = await bench()
+    const rejections: unknown[] = []
+    const onUnhandled = (reason: unknown): void => { rejections.push(reason) }
+    // queueMicrotask throws surface as uncaughtException, not a rejection.
+    process.on('unhandledRejection', onUnhandled)
+    process.on('uncaughtException', onUnhandled)
+    try {
+      // This provider activates BEFORE any hole exists: both deferrals wait.
+      // (Duplicate rows of the SAME package converge silently — the deferral
+      // skips a hole its own component already occupies; the conflict needs
+      // a rival provider.)
+      await b.ctx.plugin({ inject: [...inject], apply }).await()
+      b.declare()
+      // A rival occupies both holes ahead of the pending microtask flush.
+      b.slots.register({ name: HOLES[0] } as never, () => null)
+      b.slots.register({ name: HOLES[1] } as never, () => null)
+      await new Promise(resolve => setTimeout(resolve, 20))
+      // The rival keeps both holes; this provider rolled back wholesale and
+      // surfaced the conflict on the fail-loud channel — no partial mix.
+      for (const hole of HOLES) expect(b.slots.entries(hole)).toHaveLength(1)
+      expect(rejections.map(String).join('\n')).toContain('already has a registration')
+    } finally {
+      process.off('unhandledRejection', onUnhandled)
+      process.off('uncaughtException', onUnhandled)
+    }
+  })
+
   it('rolls back the first deferral when the second hole is already occupied', async () => {
     const b = await bench()
     b.declare()