Fix architecture-review findings in the loop and service packages

High (loop pipeline): agent/step-result now runs before the
assistant/message append so the session log records what tool dispatch
actually uses; abort is honored between tool calls, not just
mid-stream; steering drains at step start, pending steering overrides
a negative turn-continuation decision (/goal pattern), and leftover
steering is re-enqueued as queued messages so it is never stranded;
exceptions from turn-continuation listeners and session/flush are
contained to the turn (error event + agent/error) instead of killing
the driver loop.

Medium: disposal emits agent/status('disposed') and mid-turn disposal
records reason 'disposed'; duplicate LLM adapter registration throws
(all-or-nothing); SessionEvent is a real discriminated union (casts
removed); model-less agents fail with a clear actionable error unless
agent/request supplies a model.

Low: agent/queued and agent/steering carry the resolved MessageSource;
streamBlocks() yields strictly in stream order and flushes delta-only
blocks (matches generate()); BlockAssembler freezes blocks on
block-end and ignores stragglers from malformed streams; turn
numbering is a counter seeded from the log (fork-safe); LoopAgent's
stop disposer is infallible (a throwing status listener cannot skip
registry cleanup); AgentLoop.create uses a generator effect so stop
and unregister are independent disposables; SessionStore wires
onAppend inside its effect.

21 regression tests added (review-fixes.spec.ts), organized by
finding. Docs updated: loop pseudocode (status emissions, ordering,
error containment, steering guarantees) and waterfall composition
caveat in docs/architecture.md; AGENTS.md notes that excessive tests
are welcome.

packages/llm/src/index.ts

@@ -56,6 +56,11 @@ export class LlmService extends Service {
   /** Register an adapter for the given model names. Disposed with the fiber. */
   registerAdapter(models: string[], adapter: LlmAdapter): () => void {
     return this.ctx.effect(() => {
+      for (const model of models) {
+        if (this.adapters.has(model)) {
+          throw new LlmError(`an adapter for model "${model}" is already registered`, 'DUPLICATE_ADAPTER')
+        }
+      }
       for (const model of models) this.adapters.set(model, adapter)
       this.ctx.emit('llm/adapter-change')
       return () => {
@@ -85,14 +90,19 @@ export class LlmService extends Service {
 
   /**
    * Stream one model call as completed content blocks — a convenience view
-   * for consumers that don't care about token-level deltas.
+   * for consumers that don't care about token-level deltas. Blocks are
+   * yielded strictly in stream order as soon as they (and everything before
+   * them) complete; blocks left open at end of stream (delta-only protocols)
+   * are assembled and flushed last, so the sequence always equals
+   * `generate()`'s `message.content`.
    */
   async * streamBlocks(options: GenerateOptions): AsyncIterable<ContentBlock> {
     const assembler = new BlockAssembler()
     for await (const chunk of this.stream(options)) {
-      const block = assembler.push(chunk)
-      if (block) yield block
+      assembler.push(chunk)
+      yield * assembler.flushReady()
     }
+    yield * assembler.flushRemaining()
   }
 
   /** One model call, fully assembled (drains the chunk stream). */