Add abstract service interface packages

@deepseek-ai/dsh-llm: provider-neutral content-block vocabulary
(merge-extensible maps), raw StreamChunk protocol, ToolSchema,
abstract LlmAdapter, LlmService adapter registry, BlockAssembler.

@deepseek-ai/dsh-session: event-sourced Session (append-only log,
deriveMessages; context/steering render as tagged envelopes),
SessionStore, session/event + awaited session/flush durability seam.

@deepseek-ai/dsh-system-prompt: ordered sections + tool-schema
providers; assemble() through the system-prompt/assemble waterfall.
Tool schemas are part of the assembly by design.

@deepseek-ai/dsh-tools: tool registry feeding schemas into the
assembly; execute() through the tools/execute waterfall (the single
sandbox/permission/hook seam).

@deepseek-ai/dsh-agent: Agent interface (send/steer/inject/abort,
spawn/fork TODO seams), AgentRegistry, and the full agent/* event
taxonomy so plugins never depend on the concrete loop.

packages/system-prompt/src/index.ts

@@ -0,0 +1,98 @@
+import { Context, Service } from 'cordis'
+import type { ToolSchema } from '@deepseek-ai/dsh-llm'
+
+declare module 'cordis' {
+  interface Context {
+    systemPrompt: SystemPrompt
+  }
+
+  interface Events {
+    /** Waterfall around prompt assembly — mutate/extend the assembly. */
+    'system-prompt/assemble'(this: SystemPrompt, assembly: PromptAssembly, next: () => Promise<PromptAssembly>): Promise<PromptAssembly>
+    /** A section or tool provider was registered or unregistered. */
+    'system-prompt/change'(): void
+  }
+}
+
+/** One contributed section of the system prompt. */
+export interface PromptSection {
+  /** Unique name (diagnostics / dedup). */
+  name: string
+  /** Sections are concatenated in ascending order. */
+  order: number
+  /** Static text or a provider evaluated at each assembly. */
+  text: string | (() => string)
+}
+
+/**
+ * The assembled prompt.
+ *
+ * Tool schemas are part of the assembly by design: "what the model is told it
+ * can do" is one coherent thing managed here, even though adapters transmit
+ * `tools` as a separate wire field rather than prompt text.
+ *
+ * Merge-extensible: plugins can declare extra fields on this interface.
+ */
+export interface PromptAssembly {
+  sections: PromptSection[]
+  tools: ToolSchema[]
+}
+
+/** Renders the text part of an assembly (sections joined by blank lines). */
+export function renderPrompt(assembly: PromptAssembly): string {
+  return assembly.sections
+    .map(section => typeof section.text === 'function' ? section.text() : section.text)
+    .filter(text => text.length > 0)
+    .join('\n\n')
+}
+
+/**
+ * Registry service (`ctx.systemPrompt`): plugins contribute ordered text
+ * sections and tool-schema providers; the agent loop calls `assemble()` once
+ * per step.
+ */
+export class SystemPrompt extends Service {
+  private sections: PromptSection[] = []
+  private toolProviders: (() => ToolSchema[])[] = []
+
+  constructor(ctx: Context) {
+    super(ctx, 'systemPrompt')
+  }
+
+  /** Contribute a section. Disposed with the calling fiber. */
+  section(section: PromptSection): () => void {
+    return this.ctx.effect(() => {
+      this.sections.push(section)
+      this.ctx.emit('system-prompt/change')
+      return () => {
+        const index = this.sections.indexOf(section)
+        if (index >= 0) this.sections.splice(index, 1)
+        this.ctx.emit('system-prompt/change')
+      }
+    }, 'systemPrompt.section()')
+  }
+
+  /** Contribute tool schemas (evaluated at each assembly). Disposed with the fiber. */
+  tools(provider: () => ToolSchema[]): () => void {
+    return this.ctx.effect(() => {
+      this.toolProviders.push(provider)
+      this.ctx.emit('system-prompt/change')
+      return () => {
+        const index = this.toolProviders.indexOf(provider)
+        if (index >= 0) this.toolProviders.splice(index, 1)
+        this.ctx.emit('system-prompt/change')
+      }
+    }, 'systemPrompt.tools()')
+  }
+
+  /** Assemble the current prompt (sections sorted, tools collected). */
+  assemble(): Promise<PromptAssembly> {
+    const assembly: PromptAssembly = {
+      sections: [...this.sections].sort((a, b) => a.order - b.order),
+      tools: this.toolProviders.flatMap(provider => provider()),
+    }
+    return this.ctx.waterfall(this, 'system-prompt/assemble', assembly, async () => assembly)
+  }
+}
+
+export default SystemPrompt