Merge remote-tracking branch 'origin/master' into codex/project-instruction-files

# Conflicts:
#	docs/event-producer-consumer.md
#	docs/rfc/README.md
#	packages/core/agent-core/src/index.ts
#	packages/ui/acp-agent/src/index.ts

packages/core/agent-core/README.md

@@ -19,6 +19,7 @@ This is the package to read to see **the whole plugin tree at once** — the tea
 @deepseek-ai/dsh-tool-bash        the model-facing bash/bash_output/bash_kill schemas
 @deepseek-ai/dsh-project-instructions  AGENTS.md/CLAUDE.md workspace context loader
 @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
@@ -35,10 +36,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
 

packages/core/agent-core/package.json

@@ -46,6 +46,10 @@
     "@deepseek-ai/dsh-system-prompt": "workspace:^",
     "@deepseek-ai/dsh-tool-bash": "workspace:^",
     "@deepseek-ai/dsh-tools": "workspace:^",
-    "cordis": "^4.0.0-rc.6"
+    "cordis": "^4.0.0-rc.6",
+    "schemastery": "^3.18.0"
+  },
+  "dependencies": {
+    "schemastery": "^3.18.0"
   }
 }

packages/core/agent-core/src/index.ts

@@ -47,7 +47,7 @@ import Timer from '@cordisjs/plugin-timer'
 import z 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 AgentRegistry from '@deepseek-ai/dsh-agent'
 import * as invariants from '@deepseek-ai/dsh-invariants'
@@ -58,41 +58,53 @@ import AgentLoop, { type Config as AgentLoopConfig } from '@deepseek-ai/dsh-agen
 export const name = 'agent-core'
 
 /**
- * Bundle config: the agent-loop `agents` list plus project-instruction loader
- * controls. `agents` defaults to `[]` — an app that pre-creates no agents (the
- * ACP bridge creates them on demand at `session/new`) simply omits it; an app
- * that needs a pre-created `main` (the stdio chat) supplies one.
+ * 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 `projectInstructions` to the
+ * project-instructions plugin. All are optional INPUT here because each owner
+ * supplies its own default; this bundle's schema composes the owners' schemas
+ * so validation and defaulting can never drift from them.
  */
 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']
+  /** Project-instruction loader controls; set `false` for hermetic prompts. */
   projectInstructions?: projectInstructions.Config | false
 }
 
-const AgentsConfig = z.array(z.object({
-  id: z.string().required(),
-  model: z.string(),
-  systemPrompt: z.string(),
-  resumeSessionId: z.string(),
-})).default([])
-
-export const Config: z<Config> = z.object({
-  agents: AgentsConfig,
+const ProjectInstructionsConfig = z.object({
   projectInstructions: z.union([z.const(false), projectInstructions.Config]),
-}) as unknown as z<Config>
+}) as unknown as z<Pick<Config, 'projectInstructions'>>
+
+/** Intersect the owners' schemas so validation + defaulting stay identical. */
+export const Config = z.intersect([
+  AgentLoop.Config,
+  SystemPrompt.Config,
+  ProjectInstructionsConfig,
+]) 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 extension plugins that wrap the
- * request/tool seams, then the loop that drives them.
+ * `agent-loop` receives the forwarded `agents` list and `system-prompt` the
+ * forwarded `persona`. Project-instructions receives its own forwarded config
+ * or loads with defaults. 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 extension plugins that wrap request/tool seams, 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(AgentRegistry)
   ctx.plugin(invariants)

packages/core/agent-core/tests/agent-core.spec.ts

@@ -66,11 +66,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()
   })
 
@@ -96,7 +112,8 @@ describe('dsh-agent-core bundle', () => {
 
       expect(adapter.requests[0]?.messages[0]?.role).toBe('user')
       expect(firstText(adapter.requests[0]?.messages[0])).toContain('bundled project rule')
-      expect(adapter.requests[0]?.system).toBeUndefined()
+      expect(adapter.requests[0]?.system).toContain('You are an AI agent powered by the DeepSeek Harness SDK.')
+      expect(adapter.requests[0]?.system).not.toContain('bundled project rule')
       await handle.dispose()
       await ctx.fiber.dispose()
     } finally {

packages/core/agent-core/tsconfig.json

@@ -11,6 +11,9 @@
     {
       "path": "../../../vendor/cordis"
     },
+    {
+      "path": "../../../vendor/schemastery"
+    },
     {
       "path": "../../../vendor/timer"
     },