Merge remote-tracking branch 'origin/master' into codex/skill-system

# Conflicts: # docs/event-producer-consumer.md # docs/module-graph.md # docs/rfc/README.md # packages/core/agent-core/package.json # packages/core/agent-core/src/index.ts # packages/core/agent-loop/README.md # packages/core/agent-loop/src/index.ts # packages/ui/acp-agent/src/index.ts # packages/ui/acp-agent/tests/acp-agent.spec.ts # packages/ui/stdio-agent/README.md # packages/ui/stdio-agent/src/index.ts # packages/ui/stdio-agent/tests/stdio-agent.spec.ts
2026-07-06 10:09:26 +08:00
parent ad14b210bf 9c0cd392b9
commit 545b2775db
205 changed files with 2738 additions and 1268 deletions
--- a/packages/core/agent-core/README.md
+++ b/packages/core/agent-core/README.md
@@ -18,6 +18,7 @@ This is the package to read to see **the whole plugin tree at once** — the tea
@deepseek-ai/dsh-invariants       dev-mode event-contract assertions
@deepseek-ai/dsh-tool-bash        the model-facing bash/bash_output/bash_kill schemas
@deepseek-ai/dsh-agent-loop       THE concrete loop (gets the forwarded `agents`)
+                                  (dsh-system-prompt gets the forwarded `persona`)
 ```

 ## What it deliberately leaves OUTSIDE the bundle
@@ -34,10 +35,11 @@ This is the [interface/implementation/consumer seam](../../../docs/rfc/implement

 ```ts
 import type { Config } from '@deepseek-ai/dsh-agent-core'
-// Config === AgentLoop.Config — the `agents` list, default [].
+// { agents?, persona? } — the schema is z.intersect([AgentLoop.Config, SystemPrompt.Config]),
+// so validation and defaulting can never drift from the owners'.
 ```

-The bundle FORWARDS `agent-loop`'s `agents` list as its own (default `[]`), so each app supplies its own pre-created agents — a stdio app pre-creates a `main`; the ACP app pre-creates none (it creates agents on demand at `session/new`). Forwarding the list is exactly why the loop can live in the shared spine even though the apps disagree on which agents to pre-create.
+The bundle FORWARDS each field to the child that owns it: `agents` to `agent-loop` (default `[]`), so each app supplies its own pre-created agents — a stdio app pre-creates a `main`; the ACP app pre-creates none (it creates agents on demand at `session/new`) — and `persona` to `dsh-system-prompt` (default `''`), the deployment's persona section. Forwarding is exactly why the owners can live in the shared spine even though the apps disagree on what to configure.

 ## Why a code bundle, not a shared YAML include

--- a/packages/core/agent-core/package.json
+++ b/packages/core/agent-core/package.json
@@ -47,7 +47,9 @@
    "@deepseek-ai/dsh-tool-bash": "workspace:^",
    "@deepseek-ai/dsh-tool-skill": "workspace:^",
    "@deepseek-ai/dsh-tools": "workspace:^",
-    "cordis": "^4.0.0-rc.6",
+    "cordis": "^4.0.0-rc.6"
+  },
+  "dependencies": {
    "schemastery": "^3.18.0"
  }
 }
--- a/packages/core/agent-core/src/index.ts
+++ b/packages/core/agent-core/src/index.ts
@@ -45,10 +45,9 @@
 import type { Context } from 'cordis'
 import Timer from '@cordisjs/plugin-timer'
 import z from 'schemastery'
-import type Schema from 'schemastery'
 import LlmService from '@deepseek-ai/dsh-llm'
 import SessionStore from '@deepseek-ai/dsh-session'
-import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
+import SystemPrompt, { type Config as SystemPromptConfig } from '@deepseek-ai/dsh-system-prompt'
 import ToolRegistry from '@deepseek-ai/dsh-tools'
 import SkillService, { type Config as SkillConfig } from '@deepseek-ai/dsh-skill'
 import AgentRegistry from '@deepseek-ai/dsh-agent'
@@ -60,47 +59,58 @@ import AgentLoop, { type Config as AgentLoopConfig } from '@deepseek-ai/dsh-agen
 export const name = 'agent-core'

 /**
- * Bundle config: the agent-loop `agents` list plus skill discovery config.
- * Default `agents: []` means an app that pre-creates no agents (the ACP bridge
- * creates them on demand at `session/new`) can omit it; an app that needs a
- * pre-created `main` (the stdio chat) supplies one. `skills` is forwarded to
- * {@link @deepseek-ai/dsh-skill}, so leaf cordis.yml files can change DSH/user
- * skill roots and caps without code changes.
+ * Bundle config: each field forwarded verbatim to the child that owns it —
+ * `agents` to the agent loop (an app that pre-creates no agents, like the ACP
+ * bridge, simply omits it), `persona` to the system-prompt plugin (the
+ * deployment's persona section), and `skills` to the skill service. All three
+ * are optional INPUT here because each owner's schema supplies the default
+ * (`[]` / `''` / the DSH skill roots); the schema is the INTERSECTION of the
+ * owners' own schemas, so validation and defaulting can never drift from them.
 */
-export interface Config extends AgentLoopConfig {
+export interface Config {
+  /** The agent-loop `agents` list (see dsh-agent-loop's `Config`). */
+  agents?: AgentLoopConfig['agents']
+  /** The deployment persona (see dsh-system-prompt's `Config`). */
+  persona?: SystemPromptConfig['persona']
  /** Skill discovery roots, system-skill installation, and prompt/cache bounds. */
  skills?: SkillConfig
 }

 /** The skill config schema exported for app packages that forward `skills`. */
-export const SkillConfigSchema: Schema<SkillConfig> = SkillService.Config
+export const SkillConfigSchema = SkillService.Config

-/** Bundle schema: reuse agent-loop's agent shape and add skill config. */
-export const Config: Schema<Config> = z.intersect([
+/** Intersect the owners' schemas so validation + defaulting stay identical. */
+export const Config = z.intersect([
  AgentLoop.Config,
+  SystemPrompt.Config,
  z.object({ skills: SkillConfigSchema }),
-])
+]) as unknown as z<Config>

 /**
 * Load the spine. Each `ctx.plugin(...)` mounts one child of the bundle fiber;
- * `agent-loop` receives the forwarded `agents` list. Load order is irrelevant
- * (cordis pends each fiber on its `inject` until the services it needs exist),
- * but the listing mirrors the dependency layering for readability: the LLM
- * vocabulary and core registries first, then the dev tripwire and the bash tool
- * consumer, then the loop that drives them.
+ * `agent-loop` receives the forwarded `agents` list and `system-prompt` the
+ * forwarded `persona`. Load order is irrelevant (cordis pends each fiber on
+ * its `inject` until the services it needs exist), but the listing mirrors the
+ * dependency layering for readability: the LLM vocabulary and core registries
+ * first, then the dev tripwire and the bash tool consumer, then the loop that
+ * drives them.
 */
 export function apply(ctx: Context, config: Config): void {
  ctx.plugin(Timer)
  ctx.plugin(LlmService)
  ctx.plugin(SessionStore)
-  ctx.plugin(SystemPrompt)
+  // The forwarded fields are validated + defaulted by this bundle's intersected
+  // schema before apply runs, so the ?? fallbacks only narrow the
+  // optional-input TYPES — they mirror the owners' schema defaults, never
+  // introduce different ones.
+  ctx.plugin(SystemPrompt, { persona: config.persona ?? '' })
  ctx.plugin(ToolRegistry)
  ctx.plugin(SkillService, config.skills ?? {})
  ctx.plugin(AgentRegistry)
  ctx.plugin(invariants)
  ctx.plugin(toolBash)
  ctx.plugin(toolSkill)
-  ctx.plugin(AgentLoop, { agents: config.agents })
+  ctx.plugin(AgentLoop, { agents: config.agents ?? [] })
 }

 export type { SkillConfig }
--- a/packages/core/agent-core/tests/agent-core.spec.ts
+++ b/packages/core/agent-core/tests/agent-core.spec.ts
@@ -98,11 +98,27 @@ describe('dsh-agent-core bundle', () => {
    await ctx.fiber.dispose()
  })

-  it('forwards a pre-created agent to the loop', async () => {
+  it('forwards a pre-created agent to the loop and the persona to system-prompt', async () => {
    const ctx = await mount({
-      agents: [{ id: AgentId('main'), model: 'mock', systemPrompt: 'hi' }],
+      agents: [{ id: AgentId('main'), model: 'mock' }],
+      persona: 'You are main.',
    })
    expect(ctx.get('agents')?.get(AgentId('main'))).toBeDefined()
+    const assembly = await ctx.get('systemPrompt')!.assemble()
+    expect(assembly.sections.find(s => s.name === 'deployment:persona')?.text).toBe('You are main.')
+    await ctx.fiber.dispose()
+  })
+
+  it('tolerates a schema-bypassing direct apply (the ?? fallbacks fire)', async () => {
+    // ctx.plugin validates + defaults the bundle config first; a direct apply
+    // skips the schema, so the forwarding `?? []` / `?? ''` are what fire.
+    const ctx = new Context()
+    agentCore.apply(ctx, {})
+    await new Promise(resolve => setTimeout(resolve, 50))
+    expect(ctx.get('agentLoop')).toBeDefined()
+    expect(ctx.get('agents')?.list()).toHaveLength(0)
+    const assembly = await ctx.get('systemPrompt')!.assemble()
+    expect(assembly.sections.find(s => s.name === 'deployment:persona')?.text).toBe('')
    await ctx.fiber.dispose()
  })

--- a/packages/core/agent-core/tsconfig.json
+++ b/packages/core/agent-core/tsconfig.json
@@ -11,6 +11,9 @@
    {
      "path": "../../../vendor/cordis"
    },
+    {
+      "path": "../../../vendor/schemastery"
+    },
    {
      "path": "../../../vendor/timer"
    },