Document the codebase thoroughly and tighten type safety

Docs: per-folder README.md for packages/ (family overview + one per
package: service, events, API, extension points, TODOs), examples/,
and examples/echo-agent/; folder-level AGENTS.md (+ CLAUDE.md
symlinks) for packages/ and vendor/; module-level doc comments in
every packages/*/src file; richer JSDoc on all exported API
(event side effects, disposal contracts, error behavior). Root
AGENTS.md gains a "Type Safety and Documentation" policy section:
the codebase aims to be very type-safe and well documented; type
gymnastics are acceptable in core packages when they improve
plugin-author DX; verbose docs are fine as long as they stay strictly
in sync with the code.

Type safety: removed the upstream-inherited "noImplicitAny": false
from tsconfig.base.json — packages/* now compile under full strict
mode; vendor/loader and vendor/include set it locally (vendor/cordis
already did). Eliminated every `: any` / `as any` from packages and
examples (catch clauses use unknown + a CodedError narrowing type;
event data access uses discriminated-union narrowing).

Typed tool schemas: new @deepseek-ai/dsh-tools schema DSL —
SchemaSpec with per-property `required: true` booleans, type-level
InferArgs<S>, a runtime SchemaSpec → JSON Schema converter, and
defineTool() so first-party tools get typed execute(args) with zero
casts (raw JSON Schema still accepted for MCP interop; chosen over
schemastery because it targets JSON Schema generation directly).
echo-tool and all test tools migrated; +7 tests.

packages/llm/src/index.ts

@@ -1,3 +1,11 @@
+/**
+ * LLM service: adapter registry with waterfall-interceptable streaming and
+ * non-streaming call surfaces. Exports the `LlmService` default, the abstract
+ * `LlmAdapter` for provider backends, and `BlockAssembler` for chunk assembly.
+ *
+ * @module @deepseek-ai/dsh-llm
+ */
+
 import { Context, Service } from 'cordis'
 import type { ContentBlock, GenerateOptions, GenerateResult, StreamChunk } from './types.ts'
 import { BlockAssembler } from './assembler.ts'
@@ -20,6 +28,7 @@ declare module 'cordis' {
   }
 }
 
+/** Typed error for LLM-related failures. The `code` string enables programmatic handling. */
 export class LlmError extends Error {
   constructor(message: string, public code: string) {
     super(message)
@@ -53,7 +62,12 @@ export class LlmService extends Service {
     super(ctx, 'llm')
   }
 
-  /** Register an adapter for the given model names. Disposed with the fiber. */
+  /**
+   * Register an adapter for the given model names. Throws `LlmError` with code
+   * `DUPLICATE_ADAPTER` if any model already has an adapter (all-or-nothing).
+   * Emits `llm/adapter-change` on registration and disposal. Disposed with the
+   * fiber.
+   */
   registerAdapter(models: string[], adapter: LlmAdapter): () => void {
     return this.ctx.effect(() => {
       for (const model of models) {
@@ -81,7 +95,11 @@ export class LlmService extends Service {
     return adapter
   }
 
-  /** Stream one model call as raw chunks (token-level deltas). */
+  /**
+   * Stream one model call as raw chunks (token-level deltas). Throws
+   * `LlmError` with code `NO_ADAPTER` if no adapter is registered for
+   * `options.model`. Dispatches through the `llm/stream` waterfall.
+   */
   stream(options: GenerateOptions): AsyncIterable<StreamChunk> {
     return this.ctx.waterfall(this, 'llm/stream', options, () => {
       return this.adapter(options.model).stream(options)
@@ -105,7 +123,11 @@ export class LlmService extends Service {
     yield * assembler.flushRemaining()
   }
 
-  /** One model call, fully assembled (drains the chunk stream). */
+  /**
+   * One model call, fully assembled (drains the chunk stream). Dispatches
+   * through the `llm/generate` waterfall (and the inner stream through
+   * `llm/stream`). Same completion guarantees as `streamBlocks()`.
+   */
   generate(options: GenerateOptions): Promise<GenerateResult> {
     return this.ctx.waterfall(this, 'llm/generate', options, async () => {
       const assembler = new BlockAssembler()