fix(agent): contain a throwing agent/disposed listener in the register disposer (Codex review)

Codex found a real teardown-leak (A): the AgentHandle's composite effect runs
its disposers as a `.then()` chain, and the register disposer emitted
`agent/disposed` UNCONTAINED. A throwing listener rejected the chain, skipping
the LATER session-detach disposer — stranding the session in the store with
`onAppend` attached (a leak AND a durability hole, since the new composite
design relies on detach running). Verified by tracing fiber.ts:299-301
(`task = task.then(dispose)`) against the yield order in AgentLoop.start.

Wrap the disposer's `agent/disposed` emit in try/catch + logger.warn (the
store entry is already removed before the emit — the useful state is captured
— so logging and continuing is correct, mirroring the guarded `agent/status`
emit in ReactLoopAgent). The sibling `agent/created` emit stays uncontained on
purpose: its throw is MEANT to propagate and roll the registration back.

Regression test (acp dispose.spec): register a throwing `agent/disposed`
listener, drive a clean turn, dispose, assert the session was STILL removed.
Confirmed it FAILS without the guard (the throw escapes dispose and detach is
skipped) and passes with it.

Also (B): document the new `prepare`/`enter`/`announce` ordered-teardown
lifecycle primitives in the dsh-session README (they are public cross-package
methods now consumed by dsh-agent-loop).

packages/acp/tests/dispose.spec.ts

@@ -248,4 +248,29 @@ describe('acp bridge — disposal & HMR safety', () => {
     expect(handleB.agent.status).not.toBe('disposed')
     await harness.dispose()
   })
+
+  it('a throwing agent/disposed listener does not prevent session removal (composite-effect containment)', async () => {
+    // The AgentHandle teardown folds session-detach, register, and loop-stop
+    // into ONE composite effect whose disposers run as a `.then()` chain. The
+    // register disposer emits `agent/disposed`; if a listener throws and the
+    // emit is UNCONTAINED, the rejected chain skips the LATER session-detach
+    // disposer — stranding the session in the store with `onAppend` attached (a
+    // leak AND a durability hole, since the new design relies on detach
+    // running). The emit must be contained. Register a throwing listener, drive
+    // a clean turn, dispose, and assert the session was STILL removed.
+    const harness = await makeBridgeHarness({ storageDir, script: [textResponse('ok')] })
+    harness.ctx.on('agent/disposed', () => { throw new Error('boom disposed listener') })
+    const handle = harness.ctx.agents.create({
+      agentId: 'guard-a', sessionId: 'guard-a', agentOptions: { model: 'mock' },
+    })
+    handle.agent.send([{ type: 'text', text: 'go' }])
+    await handle.agent.whenIdle()
+    expect(harness.ctx.sessions.get('guard-a')).toBeDefined()
+
+    // Dispose: the throwing listener must NOT break the chain before detach.
+    await handle.dispose()
+    expect(harness.ctx.agents.get('guard-a')).toBeUndefined()
+    expect(harness.ctx.sessions.get('guard-a')).toBeUndefined() // detach still ran
+    await harness.dispose()
+  })
 })