@mzzsfy/dsh-rs-workflow 0.2.3 → 1.0.0

package/lib/driver/runner.mjs

@@ -0,0 +1,173 @@
+// 批次执行:slots 解析/候选轮换/engine.start 派发/收敛记账/失败账
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { schemaOf, buildPrompt } from './prompts.mjs'
+import { stepTypeOf } from './scheduler.mjs'
+
+const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..')
+export const FLOW_EXEC_SOURCE = readFileSync(join(PKG_ROOT, 'engine', 'flow-exec.js'), 'utf8')
+
+
+const DEFAULT_SLOT = {
+  normal: 'executor',
+  loop: 'executor-loop',
+  redo: 'executor-loop',
+  escalate: 'executor-escalate',
+  approve: 'reviewer-approve',
+}
+
+// 失败账缺省上限:step.maxFail 与 budgets.maxStepFail 均缺省时兜底,防无限重试
+const DEFAULT_MAX_STEP_FAIL = 2
+
+// 步骤槽位类别:常规/循环/重做/升级/审批(显式 slot 优先,审批不可覆盖)
+export function slotCategoryOf(step, { isRedo = false, isEscalate = false } = {}) {
+  if (stepTypeOf(step) === 'approve') return 'approve'
+  if (isEscalate) return 'escalate'
+  if (isRedo) return 'redo'
+  if (step.for_each) return 'loop'
+  return 'normal'
+}
+
+// 槽位解析:候选数组按 run 级游标轮换;失败换下一候选(游标+1)
+// 显式 slot 不限类别(settings-schema:缺省绑定仅在未声明 slot 时生效)
+export function resolveSlot(step, category, slots, state) {
+  const key = step.slot ?? DEFAULT_SLOT[category]
+  const binding = slots?.[key]
+  if (binding === undefined || binding === '' || binding === null) return { slotKey: key, provider: undefined, model: undefined }
+  if (!Array.isArray(binding)) return { slotKey: key, provider: binding, model: undefined }
+  state.slotCursor ??= {}
+  const cursor = state.slotCursor[key] ?? 0
+  const candidate = binding[cursor % binding.length]
+  return { slotKey: key, provider: candidate, model: undefined, cursorKey: key }
+}
+
+function rotateCursor(state, slotKey) {
+  if (!slotKey) return
+  state.slotCursor ??= {}
+  state.slotCursor[slotKey] = (state.slotCursor[slotKey] ?? 0) + 1
+}
+
+// 单批次:组 Batch → engine.start → 收敛逐 call 记账。返回 {results, cancelled}
+export async function runBatch({ state, script, template, batch, ctx }) {
+  const { store, runId, engine, parent, signal } = ctx
+  const calls = []
+  const callMeta = new Map()
+  state.batchSeq++
+  const batchNo = state.batchSeq
+  for (const [i, item] of batch.entries()) {
+    const step = (script ?? template).steps.find((s) => s.id === item.stepId) ?? template.steps.find((s) => s.id === item.stepId)
+    const inst = item.instance
+    const redo = state.redoInfo?.[item.stepId]
+    const isRedo = !!redo
+    const category = slotCategoryOf(step, { isRedo, isEscalate: !!item.escalate })
+    const { slotKey, provider, model, cursorKey } = resolveSlot(step, category, ctx.slots, state)
+    const prompt = buildPrompt({
+      state, request: ctx.request, inputs: ctx.inputs, step, inst,
+      planStep: ctx.planStepOf?.get(item.stepId),
+      injectMessages: ctx.injectMessages, queuedMessages: ctx.queuedMessages,
+      redo, readDoc: ctx.readDoc,
+    })
+    const callId = `${item.stepId}#${inst?.key ?? '-'}@${batchNo}:${i}`
+    const label = `${step.label ?? step.id}${inst ? ` ${inst.key}` : ''}`
+    calls.push({ callId, prompt, label, schema: schemaOf(step), provider, model })
+    callMeta.set(callId, { item, step, slotKey, cursorKey, prompt, label })
+  }
+
+  for (const call of calls) {
+    const { item, prompt } = callMeta.get(call.callId)
+    const s = state.steps[item.stepId]
+    if (item.instance) {
+      const inst = s.instances.find((x) => x.key === item.instance.key)
+      if (inst) inst.status = 'running'
+    } else {
+      s.status = 'running'
+    }
+    store.step({ runId, stepId: item.stepId, instance: item.instance?.key, event: 'dispatch', body: { prompt, callLabel: call.label } })
+  }
+
+  let outcome
+  try {
+    const run = engine.start({
+      script: FLOW_EXEC_SOURCE,
+      args: { calls },
+      // 宿主 meta 契约:description 必填非空;phases 必须为 {title} 对象数组(dsh-workflow-worker-thread meta 校验)
+      meta: {
+        name: `rsww-batch-${runId}-${batchNo}`,
+        description: calls.map((c) => c.label).join(' / '),
+        phases: calls.map((c) => ({ title: c.label })),
+      },
+      parent,
+      signal,
+    })
+    outcome = await (run.result ?? run)
+  } catch (e) {
+    if (signal?.aborted) return { cancelled: true }
+    outcome = { results: calls.map((c) => ({ callId: c.callId, ok: false, error: String(e?.message ?? e) })) }
+  }
+  if (signal?.aborted) return { cancelled: true }
+  // 引擎 run.result 契约:{ value(脚本返回值), stopReason, error?, agentsStarted }
+  // stopReason 非 completed(如 cancelled/error)时 value 不可信,全部调用按失败记账
+  if (outcome?.stopReason !== undefined && outcome?.stopReason !== 'completed') {
+    const reason = String(outcome?.error ?? outcome?.stopReason)
+    return { results: calls.map((c) => ({ callId: c.callId, ok: false, error: reason })) }
+  }
+  const results = outcome?.value?.results ?? outcome?.results ?? []
+  const settled = []
+  for (const result of results) {
+    const meta = callMeta.get(result.callId)
+    if (!meta) continue
+    const s = state.steps[meta.item.stepId]
+    if (result.ok) {
+      if (meta.item.instance) {
+        const inst = s.instances.find((x) => x.key === meta.item.instance.key)
+        if (inst) {
+          inst.status = 'done'
+          inst.outputs = result.outputs
+        }
+      } else {
+        s.status = 'done'
+        s.outputs = result.outputs
+      }
+      store.step({ runId, stepId: meta.item.stepId, instance: meta.item.instance?.key, event: 'submit', body: { outputs: result.outputs } })
+    } else {
+      const failTarget = meta.item.instance ? s.instances.find((x) => x.key === meta.item.instance.key) : s
+      if (failTarget) {
+        failTarget.failCount++
+        const limit = meta.step.maxFail ?? ctx.budgets.maxStepFail ?? DEFAULT_MAX_STEP_FAIL
+        if (failTarget.failCount >= limit) {
+          failTarget.status = 'failed'
+          failTarget.error = result.error
+        } else {
+          failTarget.status = 'pending'
+          rotateCursor(state, meta.cursorKey)
+        }
+      }
+      store.step({ runId, stepId: meta.item.stepId, instance: meta.item.instance?.key, event: 'fail', body: { error: result.error, candidate: meta.slotKey } })
+    }
+    settled.push({ item: meta.item, result })
+  }
+  // 看门狗:引擎契约要求结果逐 callId 返回;缺失即引擎侧异常,按标准失败路径记账(failCount+上限)
+  const seenIds = new Set(results.map((r) => r.callId))
+  for (const call of calls) {
+    if (seenIds.has(call.callId)) continue
+    const meta = callMeta.get(call.callId)
+    const s = state.steps[meta.item.stepId]
+    const failTarget = meta.item.instance ? s.instances.find((x) => x.key === meta.item.instance.key) : s
+    const error = '引擎结果缺失该调用'
+    if (failTarget) {
+      failTarget.failCount++
+      const limit = meta.step.maxFail ?? ctx.budgets.maxStepFail ?? DEFAULT_MAX_STEP_FAIL
+      if (failTarget.failCount >= limit) {
+        failTarget.status = 'failed'
+        failTarget.error = error
+      } else {
+        failTarget.status = 'pending'
+        rotateCursor(state, meta.cursorKey)
+      }
+    }
+    store.step({ runId, stepId: meta.item.stepId, instance: meta.item.instance?.key, event: 'fail', body: { error, candidate: meta.slotKey } })
+    settled.push({ item: meta.item, result: { callId: call.callId, ok: false, error } })
+  }
+  return { settled }
+}

package/lib/driver/scheduler.mjs

@@ -0,0 +1,159 @@
+// 就绪批次计算(调度域=剧本):依赖(plan.deps,gate 预计算)/for_each 展开/并发上限/审批就绪侦测/死锁防护
+export const DEFAULT_CONCURRENCY = 4
+const SELF_KEY = '-'
+
+export function stepTypeOf(step) {
+  return step.type ?? 'ai'
+}
+
+// 升级步集(模板级语义:onExhausted 目标);是否在剧本由 planner-gate 裁决
+export function escalateOnlyIds(template) {
+  const ids = new Set()
+  for (const step of template.steps) {
+    if (stepTypeOf(step) === 'approve' && typeof step.onExhausted === 'string' && step.onExhausted !== 'blocked') {
+      ids.add(step.onExhausted)
+    }
+  }
+  return ids
+}
+
+// 剧本视图:plan.steps(ref 子序列)映射为模板步骤对象;依赖表 = gate 重算的 plan.deps
+export function scriptViewOf(template, plan) {
+  const byId = new Map(template.steps.map((s) => [s.id, s]))
+  const steps = (plan?.steps ?? []).map((p) => byId.get(p.ref)).filter(Boolean)
+  const depsById = new Map(Object.entries(plan?.deps ?? {}))
+  const planRefs = new Set((plan?.steps ?? []).map((p) => p.ref))
+  const escalateOnly = new Set([...escalateOnlyIds(template)].filter((id) => planRefs.has(id)))
+  return { steps, depsById, escalateOnly, byId }
+}
+
+const stepDone = (s) => s.status === 'done'
+const stepBlockedInput = (s) => s.status === 'failed' || s.status === 'skipped'
+
+// 数据源列表解析;源未完成返回 null
+function sourceList(state, step) {
+  const [srcId, srcOut] = step.for_each.split('.')
+  const src = state.steps[srcId]
+  if (!src || !stepDone(src)) return null
+  const list = src.outputs?.[srcOut]
+  return Array.isArray(list) ? list : []
+}
+
+function expandForEach(state, step) {
+  const s = state.steps[step.id]
+  if (s.instances.length > 0) return
+  const list = sourceList(state, step)
+  if (list === null) return
+  s.instances = list.map((item, index) => ({
+    key: `#${index + 1}`, index, item, status: 'pending', outputs: null, failCount: 0, carry: null,
+  }))
+}
+
+// 宏观状态归一:实例级失败传播为步骤失败;实例全终态推导步骤态
+function normalizeForEach(state, step) {
+  const s = state.steps[step.id]
+  if (!s || s.instances.length === 0 || s.status === 'done' || s.status === 'failed' || s.status === 'skipped') return
+  if (s.instances.some((i) => i.status === 'failed')) {
+    s.status = 'failed'
+    s.error = s.instances.find((i) => i.status === 'failed')?.error
+    return
+  }
+  if (s.instances.every((i) => i.status === 'done')) s.status = 'done'
+}
+
+// 就绪批次。kind:normal(并行 calls)/approve(外部裁决侦测)/flow(嵌套)/terminal/blocked/idle
+export function nextBatch(state, script, { concurrency = DEFAULT_CONCURRENCY } = {}) {
+  const { steps, depsById, escalateOnly } = script
+
+  // 实例失败传播与步骤态归一
+  for (const step of steps) if (step.for_each) normalizeForEach(state, step)
+
+  // 依赖失败传播(宏观级)
+  for (const step of steps) {
+    if (escalateOnly.has(step.id)) continue
+    const s = state.steps[step.id]
+    if (!s || s.status !== 'pending') continue
+    const bad = (depsById.get(step.id) ?? []).some((d) => state.steps[d] && stepBlockedInput(state.steps[d]))
+    if (bad) {
+      s.status = 'skipped'
+      s.skipReason = '依赖失败传播'
+      s.instances = []
+    }
+  }
+
+  // 审批就绪侦测:target done 且依赖 done → 进入外部裁决(waiting_approval),不派发
+  for (const step of steps) {
+    if (stepTypeOf(step) !== 'approve') continue
+    const s = state.steps[step.id]
+    if (!s || s.status !== 'pending') continue
+    const depsOk = (depsById.get(step.id) ?? []).every((d) => stepDone(state.steps[d] ?? {}))
+    const target = state.steps[step.target]
+    if (depsOk && target && stepDone(target)) {
+      return { kind: 'approve', step }
+    }
+  }
+
+  const calls = []
+  for (const step of steps) {
+    if (escalateOnly.has(step.id)) continue
+    const type = stepTypeOf(step)
+    const s = state.steps[step.id]
+    if (!s || s.status !== 'pending') continue
+    const depsOk = (depsById.get(step.id) ?? []).every((d) => stepDone(state.steps[d] ?? {}))
+    if (!depsOk) continue
+    if (type === 'flow') return { kind: 'flow', step }
+    if (type !== 'ai') continue
+    if (step.for_each) {
+      expandForEach(state, step)
+      const list = sourceList(state, step)
+      if (list !== null && list.length === 0) {
+        s.status = 'skipped'
+        s.skipReason = 'for_each 数据源为空'
+        continue
+      }
+      let prev = null
+      // sequential 缺省(spec §8):仅显式 parallel 才并行,防缺省 mode 翻转语义
+      const sequential = step.mode !== 'parallel'
+      for (const inst of s.instances) {
+        const ready = sequential
+          ? inst.status === 'pending' && (prev === null || prev.status === 'done')
+          : inst.status === 'pending'
+        if (ready && sequential && prev) inst.carry = prev.outputs
+        prev = inst
+        if (!ready) continue
+        calls.push({ stepId: step.id, instance: { key: inst.key, index: inst.index, item: inst.item, carry: inst.carry } })
+        if (calls.length >= concurrency) return { kind: 'normal', calls }
+      }
+    } else {
+      calls.push({ stepId: step.id })
+      if (calls.length >= concurrency) return { kind: 'normal', calls }
+    }
+  }
+  if (calls.length > 0) return { kind: 'normal', calls }
+
+  // 升级步:唯一触发边 = 审批耗尽(escalateReady 标记)
+  for (const id of escalateOnly) {
+    const s = state.steps[id]
+    if (s && s.status === 'pending' && s.escalateReady) return { kind: 'normal', calls: [{ stepId: id, escalate: true }] }
+  }
+
+  const anyRunning = steps.some((step) => {
+    const s = state.steps[step.id]
+    if (!s) return false
+    return s.status === 'running' || (s.instances ?? []).some((i) => i.status === 'running')
+  })
+  const anyPending = steps.some((step) => {
+    const s = state.steps[step.id]
+    if (!s || s.status !== 'pending') return false
+    if (escalateOnly.has(step.id)) return !!s.escalateReady
+    return true
+  })
+
+  if (!anyRunning) {
+    if (anyPending) return { kind: 'blocked', reason: '无就绪且无在飞但存在未完成步骤(依赖链缺陷)' }
+    return { kind: 'terminal' }
+  }
+  return { kind: 'idle' }
+}
+
+export { SELF_KEY }

package/lib/index.js

@@ -1,214 +1,31 @@
-/**
- * dsh-rs-workflow — 若水工作流 (rs-workflow) 一体化插件。
- *
- * 一个包，三种行角色（由组合行的 config.role 决定，加载前经 Config 校验）：
- *   - "settings"：注册 settings 命名空间 "rs-workflow"，GUI 设置页出现配置表单
- *     （3 基础工作位 + 13 细分工作位 + 工作流默认项 + 预算，语义对齐 rs-tui 原始配置）。
- *     放在 profile 的 cordis.patch.yml（host 平面，常驻；裸包名从 profile
- *     node_modules 解析）。
- *   - "preset-sync"：把包内 preset/rs-workflow（preset.yml + agent.cordis.yml +
- *     skills 协议技能与编排引擎）幂等同步到 <dsh-home>/.agent-presets/rs-workflow，
- *     模式选择器即出现"若水工作流"。同为 host 平面行；升级包后重启即更新 preset。
- *     卸载时 pnpm 不执行依赖的 preuninstall（实验证实），残留 preset 因 tool 行
- *     import 失败在选择器显示 broken，手动清理命令见 README。
- *   - "tool"：注册模型工具 rs_workflow_config，主代理启动工作流编排前读取当前
- *     配置。放在释放出的 preset 组合（agent 平面，仅该模式可见；预设行的
- *     裸包名经 PresetTree.import 以组合 baseUrl 锚定 profile 目录、上溯
- *     node_modules 解析，直接命中 dsh plugin add 安装的本包）。
- *
- * 三个角色读写同一 settings 命名空间：settings 行负责注册与默认值（组合 config 即
- * base 层），tool 行只在执行时经 ctx.get("settings") 读取宿主进程里的同一
- * 实例，不注册、不产生第二个实例。
- */
-import z from "@deepseek-ai/schemastery";
-import { defineTool } from "@deepseek-ai/dsh-tools";
-import { presetDest, removePreset, syncPreset } from "./preset-sync.mjs";
-
-const name = "rs-workflow";
-
-const NAMESPACE = "rs-workflow";
-
-const TEMPLATES = ["auto", "lite", "plan-final", "step-review", "multi-plan"];
-
-// tool 输出 schema 的工作位键集,与 buildSlots 互为镜像(非派生):
-// tests/workflow-parity.test.mjs 对拍钉住,增删工作位须双侧同步
-const SLOT_KEYS = [
-	"planner", "executor", "reviewer",
-	"planner-triage", "planner-command", "planner-subplan", "planner-escalate",
-	"reviewer-plan", "reviewer-task", "reviewer-subplan", "reviewer-final", "reviewer-cross",
-	"executor-task", "executor-enhance", "executor-retry", "executor-escalate",
-];
-
-// 预算字段与默认值对齐 rs-tui budgets(config.ts:290-299),clamp 边界同 node-tree BUDGET_MIN/MAX
-const BUDGET_DEFAULTS = {
-	reviewRejectBeforeEscalate: 2,
-	planRejectBeforeBlocked: 2,
-	emptyOutputRetryLimit: 3,
-	reportNudgeLimit: 3,
-};
-const BUDGET_MIN = 1;
-const BUDGET_MAX = 10;
-
-/** 预算数值子 schema;clamp 在引擎侧执行,schema 只声明合法域。 */
-function buildBudgets() {
-	const budget = (def, description) => z.number().default(def).min(BUDGET_MIN).max(BUDGET_MAX).description(description);
-	return z.object({
-		reviewRejectBeforeEscalate: budget(BUDGET_DEFAULTS.reviewRejectBeforeEscalate, "任务连续被拒/失败达此值触发升级重规划(含自报失败与调用失败)"),
-		planRejectBeforeBlocked: budget(BUDGET_DEFAULTS.planRejectBeforeBlocked, "计划/子计划连续被拒达此值触发升级重规划"),
-		emptyOutputRetryLimit: budget(BUDGET_DEFAULTS.emptyOutputRetryLimit, "审批缺验证证据时重问上限,超限视为拒绝"),
-		reportNudgeLimit: budget(BUDGET_DEFAULTS.reportNudgeLimit, "执行完成但未给出交接摘要时追问上限"),
-	});
-}
-
-/** 工作位（slot）子 schema；细分位场景文案对齐 rs-tui SLOT_SCENES。string/array/{rotation} 三态：array 与 rotation 数组等价（候选依次轮换，被拒重做/重问换模型）。工厂函数保证 Config 与 SETTINGS_SCHEMA 各持独立实例。 */
-function buildSlots() {
-	const slot = (description) => z.union([z.string(), z.array(z.string()), z.object({ rotation: z.array(z.string()) })]).default("").description(description);
-	return z.object({
-		planner: slot("planner 基础位（规划域兜底）。格式 provider/model、候选数组或 {rotation:[...]}，留空 = 会话默认模型"),
-		executor: slot("executor 基础位（执行域兜底）；候选依次轮换，被拒重做/重试换模型"),
-		reviewer: slot("reviewer 基础位（审批域兜底）；候选依次轮换"),
-		"planner-triage": slot("细分位：首次分诊，分析需求选模板拆任务；缺省降级 planner"),
-		"planner-command": slot("细分位：总规划，计划重写与大纲修订；缺省降级 planner"),
-		"planner-subplan": slot("细分位：子计划细化，子计划内任务拆解；缺省降级 planner"),
-		"planner-escalate": slot("细分位：升级重规划，连续拒绝超阈后的尾段重拆；缺省降级 planner"),
-		"reviewer-plan": slot("细分位：计划审批，审批计划文本与大纲；缺省降级 reviewer"),
-		"reviewer-task": slot("细分位：任务审批，审批单个任务执行结果；缺省降级 reviewer"),
-		"reviewer-subplan": slot("细分位：子计划交付审批，审批整个子计划交付；缺省降级 reviewer"),
-		"reviewer-final": slot("细分位：单终审，末尾终审全部交付；缺省降级 reviewer，建议配更强的模型"),
-		"reviewer-cross": slot("细分位：交叉终审，多视角交叉终审链；缺省降级 reviewer，建议配更强的模型"),
-		"executor-task": slot("细分位：任务首次执行；缺省降级 executor"),
-		"executor-enhance": slot("细分位：被拒重做，携带 REJECTED 理由修改重交；缺省降级 executor"),
-		"executor-retry": slot("细分位：失败重试，自报失败/无产出后的重试；缺省降级 executor"),
-		"executor-escalate": slot("细分位：升级后执行，升级重规划产出的新任务；缺省降级 executor"),
-	});
+// dsh-rs-workflow — 若水工作流 v5:人机协作的强规则编排。
+// 主循环(人机接口+规划者)+ 分段 continuable job 编排;配置/模板存自有文件(~/.dsh/dsh-rs-workflow/v5/),
+// 不经宿主 settings 服务,不写 settings.yaml。本文件只做行角色分发,业务在 lib/ 各模块。
+import z from '@deepseek-ai/schemastery'
+import { registerBoardRoutes } from './board.mjs'
+import { registerOrchestrator } from './orchestrator.mjs'
+import { registerTemplateTool } from './template-tool.mjs'
+import { SPEC_TEXT } from './spec.mjs'
+
+export const name = 'rs-workflow'
+export { SPEC_TEXT }
+
+// 组合行 config schema(行分发字段 role 必填)
+export const Config = z.object({
+  role: z.union(['board', 'orchestrator', 'template-tool']).required(),
+  templateId: z.string().description('orchestrator:本组合锚定的模板 id(释放生成器按组合名写入);orchestrator 角色必填'),
+})
+
+export function apply(ctx, config) {
+  const cfg = Config(config || {})
+  if (cfg.role === 'board') {
+    registerBoardRoutes(ctx)
+    return
+  }
+  if (cfg.role === 'orchestrator') {
+    if (!cfg.templateId) throw new Error('orchestrator 行必须配置 templateId(组合锚定)')
+    registerOrchestrator(ctx, { templateId: cfg.templateId })
+    return
+  }
+  registerTemplateTool(ctx)
 }
-
-/** 工作流默认项子 schema。maxTasks 为 DSH 原生任务预算（rs-tui 无数量上限），约束全部任务实例化；
- *  引擎侧对 <=0/非数值另有自保回落(见 engine.js),此处 schema 声明合法域挡住非法值。 */
-const MAX_TASKS_DEFAULT = 8;
-const MAX_TASKS_MIN = 1;
-const MAX_TASKS_MAX = 64;
-function buildWorkflow() {
-	return z.object({
-		defaultTemplate: z.union(TEMPLATES).default("auto").description("默认模板：auto = planner 分诊自动选型（无信号时兜底 multi-plan）；其余 = 无信号时兜底该模板，planner 声明与分诊矩阵仍优先生效"),
-		maxTasks: z.number().default(MAX_TASKS_DEFAULT).min(MAX_TASKS_MIN).max(MAX_TASKS_MAX).description("单轮任务拆解数上限（含子计划运行时任务的全局预算）"),
-	});
-}
-
-/** settings 命名空间 schema（GUI 表单渲染的就是它，不含行角色字段）。 */
-const SETTINGS_SCHEMA = z.object({
-	slots: buildSlots(),
-	workflow: buildWorkflow(),
-	budgets: buildBudgets(),
-});
-
-/** 组合行 config schema（在 settings 之上多一个行角色字段）。 */
-const Config = z.object({
-	role: z.union(["settings", "preset-sync", "tool"]).required().description("行角色：settings = 注册 GUI 设置命名空间（host 层常驻）；preset-sync = 同步释放 agent preset 到用户预设根（host 层常驻）；tool = 注册 rs_workflow_config 模型工具（预设层）"),
-	slots: buildSlots(),
-	workflow: buildWorkflow(),
-	budgets: buildBudgets(),
-});
-
-/** 从（已解析的）行 config 里摘出 settings base 层。 */
-function baseOf(config) {
-	return { slots: config.slots, workflow: config.workflow, budgets: config.budgets };
-}
-
-function apply(ctx, config) {
-	const cfg = Config(config || {});
-	if (cfg.role === "preset-sync") {
-		try {
-			const outcome = syncPreset();
-			if (outcome === "skipped-foreign") {
-				ctx.logger?.warn?.("rs-workflow preset 目录无有效来源标记或归属他人,已保留不覆盖;确认后手动删除,下次启动即由本包接管");
-			} else if (outcome === "created") {
-				ctx.logger?.info?.(`rs-workflow preset 已首次释放到 ${presetDest()}`);
-			} else if (outcome === "updated") {
-				ctx.logger?.info?.(`rs-workflow preset 已同步更新: ${presetDest()}`);
-			}
-		} catch (error) {
-			ctx.logger?.warn?.(`rs-workflow preset 同步失败(不影响本插件其余角色): ${error?.code ? `[${error.code}] ` : ""}${error?.message ?? error}; 目标: ${presetDest()}`);
-		}
-		return;
-	}
-	if (cfg.role === "settings") {
-		ctx.inject(["settings"], (sctx) => {
-			sctx.settings.register(NAMESPACE, SETTINGS_SCHEMA, { base: baseOf(cfg) });
-		});
-		return;
-	}
-	// tools 以嵌套 inject 声明:服务缺失时仅 tool 角色保持未激活(干净禁用),
-	// settings/preset-sync 角色不再被模块级 inject 连坐(非 dsh-base 组合下旧形态
-	// 会因启动审计整树 fatal)
-	ctx.inject(["tools"], (tctx) => {
-		tctx.tools.register(defineTool({
-		name: "rs_workflow_config",
-		description: "读取若水工作流 (rs-workflow) 的当前配置：各角色的模型工作位 (slots)、工作流默认项 (workflow) 与预算 (budgets)。启动 workflow 编排前必须先调用本工具：slots 原样作为 workflow 调用 args.slots；workflow.defaultTemplate 作为 args.defaultTemplate（auto = 无信号时兜底 multi-plan，其余值 = 无信号时兜底该值；planner 声明与分诊矩阵始终优先）；workflow.maxTasks 作为 args.limits.maxTasks；budgets 原样作为 args.budgets。",
-		parameters: {},
-		output: {
-			schema: {
-				type: "object",
-				additionalProperties: false,
-				properties: {
-					slots: {
-						type: "object",
-						required: true,
-						additionalProperties: true,
-						properties: Object.fromEntries(SLOT_KEYS.map((k) => [k, {
-							oneOf: [
-								{ type: "string" },
-								{ type: "array", items: { type: "string" } },
-								{ type: "object", additionalProperties: false, properties: { rotation: { type: "array", items: { type: "string" } } } },
-							],
-						}])),
-					},
-					workflow: {
-						type: "object",
-						required: true,
-						additionalProperties: false,
-						properties: {
-							defaultTemplate: { type: "string", enum: TEMPLATES },
-							maxTasks: { type: "number" },
-						},
-					},
-					budgets: {
-						type: "object",
-						required: true,
-						additionalProperties: false,
-						properties: {
-							reviewRejectBeforeEscalate: { type: "number" },
-							planRejectBeforeBlocked: { type: "number" },
-							emptyOutputRetryLimit: { type: "number" },
-							reportNudgeLimit: { type: "number" },
-						},
-					},
-					source: { type: "string", required: true, enum: ["settings", "fallback"] },
-				},
-			},
-			render: (_args, value) => [{
-				type: "text",
-				text: JSON.stringify({ slots: value.slots, workflow: value.workflow, budgets: value.budgets }, null, 2)
-					+ (value.source === "fallback" ? "\n(设置服务不可用：返回的是组合默认值，GUI 修改不在此生效)" : ""),
-			}],
-		},
-		execute() {
-			const settings = tctx.get("settings");
-			let value;
-			try {
-				value = settings ? settings.get(NAMESPACE) : undefined;
-			} catch (error) {
-				// settings 服务在但读取失败(命名空间被移除/配置损坏)时走组合默认值,工具永不硬失败
-				ctx.logger?.warn?.(`rs-workflow settings 读取失败,回退组合默认值: ${error?.message ?? error}`);
-			}
-			if (value) {
-				return Promise.resolve({ slots: value.slots, workflow: value.workflow, budgets: value.budgets, source: "settings" });
-			}
-			return Promise.resolve({ slots: cfg.slots, workflow: cfg.workflow, budgets: cfg.budgets, source: "fallback" });
-		},
-		presentCall: () => ({ card: "generic", title: "读取若水工作流配置", kind: "other", rawInput: {} }),
-	}));
-	});
-}
-
-export { BUDGET_DEFAULTS, BUDGET_MAX, BUDGET_MIN, Config, MAX_TASKS_DEFAULT, MAX_TASKS_MAX, MAX_TASKS_MIN, NAMESPACE, SETTINGS_SCHEMA, TEMPLATES, apply, name, presetDest, removePreset, syncPreset };