refactor(loader): resolve config after injected services

packages/bundle/headless/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/bundle/headless/README.md
-README.md: 45c87f0c85cbb68ad0366ea5f2c86e55fc307309
-README.zh.md: 22322692450fa85a87e9faf903abee0d38968f91
+README.md: 459d0f32788265d43e75922067da3c03d054f444
+README.zh.md: e3ca9d13512e3a13ac71c5cda650fca958609062

packages/bundle/headless/README.md

@@ -2,7 +2,7 @@
 
 English | [中文](README.zh.md)
 
-The dsh one-shot bundle. [`cordis.patch.yml`](cordis.patch.yml) rides directly over [`dsh-base`](../base/README.md): it supplies the coding persona and tool mode, disables HMR, mounts Code Mode's worker as a core execution capability, and inserts this package's `headless-runner` plugin (config `{task}`, shipped disabled until the startup row supplies the task). It mounts no Host, HTTP server, Web runtime, or browser plugin.
+The dsh one-shot bundle. [`cordis.patch.yml`](cordis.patch.yml) rides directly over [`dsh-base`](../base/README.md): it supplies the coding persona and tool mode, disables HMR, mounts Code Mode's worker as a core execution capability, and inserts this package's `headless-runner` plugin (config `{task}`, resolved from the injected startup service). It mounts no Host, HTTP server, Web runtime, or browser plugin.
 
 After the Loader settles, the runner reads the shared [`ctx.agentDefaultModel`](../../core/agent-default-model/README.md), creates one fresh persisted Agent through `ctx.agents`, submits the task as an ordinary user message, and waits for quiescence. It flushes the Session before folding the owned durable event interval, writes the last non-empty assistant text to stdout, and requests exit through the launcher-provided `ctx.headlessIo` host hook (final `turn/end` completed → 0, otherwise 1). A terminal `error` reason also writes its code and message to stderr; successful runs keep stderr empty. The process opens no listening port. The task text is this app's command line: the `headless-startup` row ([`src/startup.ts`](src/startup.ts)) reads it as the positional argument of `dsh --profile headless "task"` from `ctx.cmdlineArgs` ([`dsh-cmdline`](../../boot/cmdline/README.md)), prints the app's `--help`, and rejects an invocation with no task instead of letting the runner's schema fail.
 

packages/bundle/headless/README.zh.md

@@ -2,7 +2,7 @@
 
 [English](README.md) | 中文
 
-dsh 一次性任务组合包。[`cordis.patch.yml`](cordis.patch.yml) 直接叠加在 [`dsh-base`](../base/README.md) 之上：提供编码 persona 和工具模式、禁用 HMR（热模块替换）、将 Code Mode 的 worker 作为核心执行能力挂载，并插入本包的 `headless-runner` 插件（配置为 `{task}`，在启动行供给任务之前以禁用状态交付）。它不挂载任何 Host、HTTP server、Web runtime 或浏览器插件。
+dsh 一次性任务组合包。[`cordis.patch.yml`](cordis.patch.yml) 直接叠加在 [`dsh-base`](../base/README.md) 之上：提供编码 persona 和工具模式、禁用 HMR（热模块替换）、将 Code Mode 的 worker 作为核心执行能力挂载，并插入本包的 `headless-runner` 插件（配置为 `{task}`，从注入的启动服务解析）。它不挂载任何 Host、HTTP server、Web runtime 或浏览器插件。
 
 Loader 结算后，runner 读取共享的 [`ctx.agentDefaultModel`](../../core/agent-default-model/README.md)，通过 `ctx.agents` 创建一个全新的持久化 Agent（智能体），将任务作为普通用户消息提交，并等待完全停稳。它对 Session 执行 flush 后再汇总自身持有的持久化事件区间，将最后一条非空 assistant 文本写入 stdout，再经启动器提供的 `ctx.headlessIo` 宿主钩子请求退出（最终 `turn/end` 完成 → 0，否则为 1）。最终 reason 为 `error` 时，还会将持久化的 code 与 message 写入 stderr；成功运行时 stderr 保持为空。进程不会打开监听端口。任务文本就是这个应用的命令行：`headless-startup` 行（[`src/startup.ts`](src/startup.ts)）从 `ctx.cmdlineArgs`（[`dsh-cmdline`](../../boot/cmdline/README.md)）把它读作 `dsh --profile headless "task"` 的位置参数，打印应用自己的 `--help`，并拒绝没有任务的调用，而不是让 runner 的 schema 失败。
 

packages/bundle/headless/cordis.patch.yml

@@ -33,4 +33,4 @@
       name: '@deepseek-ai/dsh-headless'
       inject: [headlessStartup]
       config:
-        task: !!js ctx.get('headlessStartup')?.task
+        task: !!js ctx.headlessStartup.task

packages/bundle/headless/src/startup.ts

@@ -64,7 +64,7 @@ function planHeadlessStartup(program: Command, rows: readonly EntryOptions[]): H
 }
 
 /**
- * Resolve the task and start the runner that reads it.
+ * Resolve the task for the runner waiting on `headlessStartup`.
  * @param ctx - plugin context carrying the command line and the Loader.
  * @returns nothing once the runner is started, or once `--help` or a missing task requested exit.
  */

packages/bundle/headless/tests/startup.spec.ts

@@ -1,8 +1,7 @@
 /**
- * The one-shot app's startup row over a REAL Loader tree: the task
- * positional becomes the value the runner row reads, a missing task is a usage
- * error, and the web service this app absorbs is provided too, so the web rows
- * it rides over resolve on their own fallbacks.
+ * The one-shot app's startup row over a real Loader tree: the task positional
+ * becomes the injected runner config, while help and usage errors leave the
+ * runner pending.
  */
 
 import { mkdtempSync, writeFileSync } from 'node:fs'
@@ -13,7 +12,6 @@ import { Context } from 'cordis'
 import Loader from '@cordisjs/plugin-loader'
 import Include from '@cordisjs/plugin-include'
 import { internals, provideCmdline } from '@deepseek-ai/dsh-cmdline'
-import { WEB_STARTUP_SERVICE } from '@deepseek-ai/dsh-web-app/startup'
 import { afterEach, describe, expect, it } from 'vitest'
 import { apply, HEADLESS_STARTUP_SERVICE, type HeadlessStartupValues } from '../src/startup.ts'
 
@@ -21,6 +19,7 @@ import { apply, HEADLESS_STARTUP_SERVICE, type HeadlessStartupValues } from '../
 interface Observed {
   exits: number[]
   out: string
+  runnerConfig?: unknown
 }
 
 const disposers: (() => Promise<void>)[] = []
@@ -32,22 +31,20 @@ afterEach(async () => {
 })
 
 /**
- * Mount the real startup row over stand-ins for the runner row and one web
- * row this app absorbs, the way a profile mounts phase one.
+ * Mount the real startup row over a runner stand-in.
  * @param args - the invocation's inner arguments.
- * @param options - fixture knobs for the shapes a composition can take.
- * @returns the resolved service values (absent when the app requested exit) and what the boot observed.
+ * @param options - fixture knobs for invalid compositions.
+ * @returns the resolved startup value and observed runner/process effects.
  */
 async function bootStartup(
   args: string[],
   options: { withoutRunner?: boolean } = {},
-): Promise<{ task: HeadlessStartupValues | undefined; web: unknown; observed: Observed }> {
+): Promise<{ task: HeadlessStartupValues | undefined; observed: Observed }> {
   const dir = mkdtempSync(join(tmpdir(), 'dsh-headless-startup-'))
   const observed: Observed = { exits: [], out: '' }
-  writeFileSync(join(dir, 'row.mjs'), 'export function apply() {}\n')
-  // The Loader imports a row through Node's own resolver, which cannot resolve
-  // this workspace's sources; the row delegates to the real plugin the test
-  // imported through the source-plane path mapping.
+  writeFileSync(join(dir, 'row.mjs'), 'export function apply(_ctx, config) { globalThis.__headlessStartupObserved.runnerConfig = config }\n')
+  // Loader imports through Node's resolver, so this fixture delegates to the
+  // source-plane plugin already imported by the test.
   writeFileSync(join(dir, 'startup.mjs'), `
 export const name = 'headless-startup'
 export const inject = ['cmdlineArgs']
@@ -55,16 +52,11 @@ export const apply = ctx => globalThis.__headlessStartupApply(ctx)
 `)
   const rowUrl = pathToFileURL(join(dir, 'row.mjs')).href
   writeFileSync(join(dir, 'cordis.yml'), [
-    // A composition that lost the runner still injects the service, so the
-    // startup row reaches its own row check rather than the generic one.
     options.withoutRunner === true ? '- id: displaced-runner' : '- id: headless-runner',
     `  name: ${rowUrl}`,
     `  inject: [${HEADLESS_STARTUP_SERVICE}]`,
-    '  disabled: true',
-    '- id: webserver',
-    `  name: ${rowUrl}`,
-    `  inject: [${WEB_STARTUP_SERVICE}]`,
-    '  disabled: true',
+    '  config:',
+    '    task: !!js ctx.headlessStartup.task',
     '- id: headless-startup',
     `  name: ${pathToFileURL(join(dir, 'startup.mjs')).href}`,
     '  inject: [cmdlineArgs]',
@@ -73,7 +65,12 @@ export const apply = ctx => globalThis.__headlessStartupApply(ctx)
   const observing = { write: (chunk: string) => { observed.out += chunk; return true } }
   internals.stdout = observing
   internals.stderr = observing
-  ;(globalThis as unknown as { __headlessStartupApply: typeof apply }).__headlessStartupApply = apply
+  const globals = globalThis as unknown as {
+    __headlessStartupApply: typeof apply
+    __headlessStartupObserved: Observed
+  }
+  globals.__headlessStartupApply = apply
+  globals.__headlessStartupObserved = observed
 
   const ctx = new Context()
   await ctx.plugin(Loader)
@@ -84,38 +81,35 @@ export const apply = ctx => globalThis.__headlessStartupApply(ctx)
   disposers.push(async () => { await ctx.fiber.dispose() })
   return {
     task: ctx.get(HEADLESS_STARTUP_SERVICE) as HeadlessStartupValues | undefined,
-    web: ctx.get(WEB_STARTUP_SERVICE),
     observed,
   }
 }
 
 describe('headless startup', () => {
-  it('joins the task positional into the value the runner reads', async () => {
+  it('joins the task positional into the runner config', async () => {
     const { task, observed } = await bootStartup(['run', 'the', 'tests'])
     expect(task).toEqual({ task: 'run the tests' })
+    expect(observed.runnerConfig).toEqual({ task: 'run the tests' })
     expect(observed.exits).toEqual([])
   })
 
-  it('provides the web service it absorbed, so those rows resolve on their own fallbacks', async () => {
-    const { web } = await bootStartup(['task'])
-    expect(web).toEqual({ task: 'task' })
-  })
-
-  it('rejects an invocation with no task instead of failing inside the runner schema', async () => {
+  it('rejects an invocation with no task and leaves the runner pending', async () => {
     const { task, observed } = await bootStartup([])
     expect(observed.out).toContain('a task is required')
     expect(task).toBeUndefined()
+    expect(observed.runnerConfig).toBeUndefined()
     expect(observed.exits).toEqual([1])
   })
 
-  it('prints its own help and resolves nothing', async () => {
+  it('prints its own help and leaves the runner pending', async () => {
     const { task, observed } = await bootStartup(['--help'])
     expect(observed.out).toContain('dsh --profile headless')
     expect(task).toBeUndefined()
+    expect(observed.runnerConfig).toBeUndefined()
     expect(observed.exits).toEqual([0])
   })
 
-  it('fails the boot when the composition has no runner row to give the task to', async () => {
+  it('fails when the composition has no runner row', async () => {
     await expect(bootStartup(['task'], { withoutRunner: true }))
       .rejects.toThrow('the composition has no waiting "headless-runner" row')
   })