@mzzsfy/dsh-rs-workflow 0.2.4 → 1.0.1

package/lib/template.mjs

@@ -0,0 +1,341 @@
+// 模板静态校验器:DSL v5 唯一权威(board 保存校验唯一入口);v5 新增顶层 autoApprove 键
+
+export const SLOT_KEYS = ['planner', 'executor', 'reviewer', 'executor-loop', 'reviewer-approve', 'executor-escalate']
+const TOP_FIELDS = new Set(['id', 'label', 'description', 'inputs', 'steps', 'autoApprove'])
+const STEP_FIELDS = new Set(['id', 'label', 'slot', 'prompt', 'load', 'outputs', 'listOutputs', 'after', 'maxFail', 'for_each', 'mode', 'type', 'flow', 'input', 'target', 'rounds', 'onExhausted'])
+const ID_RE = /^[a-z][a-z0-9-]*$/
+const INPUT_NAME_RE = /^[a-z][a-zA-Z0-9]*$/
+// 保留步骤 id:{input.x} 占位符以入参命名空间优先解析,同 id 步骤产出会被遮蔽
+const RESERVED_STEP_IDS = new Set(['input'])
+const PLACEHOLDER_RE = /\{([^{}]+)\}/g
+const LOAD_PREFIX_RE = /^(skill|doc):/
+const MAX_ROUND = 10
+const MAX_NEST_DEPTH = 3
+
+const VERDICT_SCHEMA = {
+  type: 'object',
+  required: ['verdict', 'comments'],
+  additionalProperties: false,
+  properties: { verdict: { type: 'string', enum: ['APPROVED', 'REJECTED'] }, comments: { type: 'string' } },
+}
+
+const err = (target, message) => ({ target, message })
+const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v)
+const placeholdersOf = (text) => [...String(text).matchAll(PLACEHOLDER_RE)].map((m) => m[1])
+
+// JSON 解析;失败抛错,调用方经 parseErrorLine 提取行号
+export function parseTemplate(text) {
+  return JSON.parse(text)
+}
+
+export function parseErrorLine(message) {
+  const text = String(message)
+  // V8 JSON.parse 形态 "(line 1 column 3)" 与 "3:5" 位置形态双兼容
+  const v8 = text.match(/\bline (\d+)\b/)
+  if (v8) return Number(v8[1])
+  const m = text.match(/(?:^|\s)(\d+):(\d+)(?:\s|$|\))/)
+  return m ? Number(m[1]) : null
+}
+
+// 单模板校验:结构/字段/引用/环/审批与升级规则;返回 errors[](空=通过)
+export function validateTemplate(t) {
+  const errors = []
+  if (!isObj(t)) return [err('json', '模板必须是对象')]
+  for (const k of Object.keys(t)) if (!TOP_FIELDS.has(k)) errors.push(err(`top:${k}`, `未知顶层字段 ${k}`))
+  if (typeof t.id !== 'string' || !ID_RE.test(t.id)) errors.push(err('top:id', 'id 必填且须匹配 ^[a-z][a-z0-9-]*$'))
+  if (typeof t.label !== 'string' || t.label.trim() === '') errors.push(err('top:label', 'label 必填且为非空字符串'))
+  if (typeof t.description !== 'string' || t.description.trim() === '') errors.push(err('top:description', 'description 必填且为非空字符串(分诊目录/保底 brief 依据)'))
+  if (t.autoApprove !== undefined && typeof t.autoApprove !== 'boolean') errors.push(err('top:autoApprove', 'autoApprove 须为布尔(缺省 false;true = 审批由主循环代审)'))
+
+  const declaredInputs = new Set()
+  if (t.inputs !== undefined) {
+    if (!isObj(t.inputs)) errors.push(err('top:inputs', 'inputs 须为对象(name: 说明)'))
+    else {
+      for (const [k, v] of Object.entries(t.inputs)) {
+        if (!INPUT_NAME_RE.test(k)) errors.push(err('top:inputs', `入参名 ${k} 须匹配 ${INPUT_NAME_RE.source}`))
+        if (typeof v !== 'string') errors.push(err('top:inputs', `入参 ${k} 的说明须为字符串`))
+        declaredInputs.add(k)
+      }
+    }
+  }
+
+  if (!Array.isArray(t.steps) || t.steps.length === 0) {
+    errors.push(err('top:steps', 'steps 必填且为非空数组'))
+    return errors
+  }
+
+  const byId = new Map()
+  for (const s of t.steps) {
+    if (isObj(s) && typeof s.id === 'string') {
+      if (byId.has(s.id)) errors.push(err('top:steps', `步骤 id 重复:${s.id}`))
+      byId.set(s.id, s)
+    }
+  }
+
+  // escalate-only 集:被任一 approve 步 onExhausted 指向的步骤;记其审批对象(target)用于产出引用禁令
+  const escalateTargetOf = new Map()
+  for (const s of t.steps) {
+    if (isObj(s) && s.type === 'approve' && typeof s.target === 'string' && typeof s.onExhausted === 'string' && s.onExhausted !== 'blocked' && byId.has(s.onExhausted)) {
+      escalateTargetOf.set(s.onExhausted, s.target)
+    }
+  }
+
+  const order = []
+  for (const s of t.steps) {
+    const sid = isObj(s) && typeof s.id === 'string' ? s.id : `#${order.length}`
+    order.push(sid)
+    if (!isObj(s)) {
+      errors.push(err('top:steps', `步骤 ${sid} 必须是对象`))
+      continue
+    }
+    if (typeof s.id !== 'string' || !ID_RE.test(s.id)) {
+      errors.push(err('top:steps', `步骤 id 必填且须匹配 ${ID_RE.source}`))
+      continue
+    }
+    const target = `step:${s.id}`
+    if (RESERVED_STEP_IDS.has(s.id)) errors.push(err(target, `步骤 id ${s.id} 为保留字,与子流程入参命名空间冲突`))
+    for (const k of Object.keys(s)) if (!STEP_FIELDS.has(k)) errors.push(err(target, `未知步骤字段 ${k}`))
+    const type = s.type === undefined ? 'ai' : s.type
+    if (!['ai', 'flow', 'approve'].includes(type)) errors.push(err(target, `type 仅支持 ai/flow/approve,得到 ${type}`))
+
+    if (s.slot !== undefined) {
+      if (!SLOT_KEYS.includes(s.slot)) errors.push(err(target, `slot 仅六键:${SLOT_KEYS.join('/')}`))
+      if (type === 'approve' && s.slot !== 'reviewer-approve') errors.push(err(target, 'approve 步骤 slot 固定 reviewer-approve,不可声明其他值'))
+    }
+    if (s.label !== undefined && typeof s.label !== 'string') errors.push(err(target, 'label 须为字符串'))
+    if (s.maxFail !== undefined && (!Number.isInteger(s.maxFail) || s.maxFail < 1 || s.maxFail > MAX_ROUND)) errors.push(err(target, `maxFail 须为 [1,${MAX_ROUND}] 整数`))
+
+    if (s.outputs !== undefined) {
+      if (!isObj(s.outputs)) errors.push(err(target, 'outputs 须为对象(字段名: 说明)'))
+      else for (const [k, v] of Object.entries(s.outputs)) {
+        if (k.trim() === '') errors.push(err(target, 'outputs 字段名不可为空'))
+        if (typeof v !== 'string') errors.push(err(target, `outputs.${k} 的说明须为字符串`))
+      }
+    }
+    const outputNames = new Set(isObj(s.outputs) ? Object.keys(s.outputs) : [])
+    if (s.listOutputs !== undefined) {
+      if (!Array.isArray(s.listOutputs)) errors.push(err(target, 'listOutputs 须为字符串数组'))
+      else for (const n of s.listOutputs) {
+        if (!outputNames.has(n)) errors.push(err(target, `listOutputs 项 ${n} 未在本步 outputs 中声明`))
+      }
+    }
+    if (s.load !== undefined) {
+      if (!Array.isArray(s.load) || s.load.some((v) => typeof v !== 'string' || !LOAD_PREFIX_RE.test(v))) {
+        errors.push(err(target, 'load 须为字符串数组且每项带 skill:/doc: 前缀'))
+      }
+    }
+    if (s.after !== undefined) {
+      if (!Array.isArray(s.after) || s.after.some((v) => typeof v !== 'string')) errors.push(err(target, 'after 须为步骤 id 数组'))
+      else for (const dep of s.after) {
+        if (dep === s.id) errors.push(err(target, 'after 不可引用自身'))
+        else if (!byId.has(dep)) errors.push(err(target, `after 引用不存在的步骤 ${dep}`))
+      }
+    }
+    if (s.for_each !== undefined) {
+      if (typeof s.for_each !== 'string' || !/^[a-z][a-z0-9-]*\.[a-zA-Z0-9]+$/.test(s.for_each)) {
+        errors.push(err(target, 'for_each 须为 "<步骤id>.<产出名>" 形态'))
+      } else {
+        const [srcId, srcOut] = s.for_each.split('.')
+        const src = byId.get(srcId)
+        if (!src) errors.push(err(target, `for_each 数据源步骤 ${srcId} 不存在`))
+        else if (!(Array.isArray(src.listOutputs) && src.listOutputs.includes(srcOut))) {
+          errors.push(err(target, `for_each 数据源 ${s.for_each} 未在该步骤 listOutputs 中声明`))
+        }
+      }
+    }
+    if (s.mode !== undefined) {
+      if (!['sequential', 'parallel'].includes(s.mode)) errors.push(err(target, 'mode 仅支持 sequential/parallel'))
+      if (s.for_each === undefined) errors.push(err(target, 'mode 仅在声明 for_each 时有效'))
+    }
+    // sequential 为缺省(spec §8),不必显式声明;校验器无副作用,仅接受缺省
+
+    if (type === 'ai') {
+      if (typeof s.prompt !== 'string' || s.prompt.trim() === '') errors.push(err(target, '普通步骤 prompt 必填'))
+      if (s.flow !== undefined || s.input !== undefined || s.target !== undefined || s.rounds !== undefined || s.onExhausted !== undefined) {
+        errors.push(err(target, '普通步骤不可声明 flow/input/target/rounds/onExhausted'))
+      }
+      if (!isObj(s.outputs) || outputNames.size === 0) errors.push(err(target, '普通步骤必须以 outputs 声明产出契约'))
+    }
+    if (type === 'approve') {
+      if (typeof s.prompt !== 'string' || s.prompt.trim() === '') errors.push(err(target, 'approve 步骤 prompt(审批口径)必填'))
+      if (s.outputs !== undefined || s.listOutputs !== undefined) errors.push(err(target, 'approve 步骤裁决契约由引擎生成,不可声明 outputs/listOutputs'))
+      if (s.for_each !== undefined || s.mode !== undefined) errors.push(err(target, 'approve 步骤不支持 for_each/mode'))
+      if (typeof s.target !== 'string' || !byId.has(s.target)) errors.push(err(target, 'approve 步骤 target 必填且须指向存在步骤'))
+      else if (s.target === s.id) errors.push(err(target, 'approve 步骤 target 不可为自身'))
+      if (s.rounds !== undefined && (!Number.isInteger(s.rounds) || s.rounds < 1 || s.rounds > MAX_ROUND)) errors.push(err(target, `rounds 须为 [1,${MAX_ROUND}] 整数`))
+      if (s.onExhausted !== undefined && s.onExhausted !== 'blocked' && !byId.has(s.onExhausted)) {
+        errors.push(err(target, `onExhausted 须为 "blocked" 或存在步骤 id,得到 ${s.onExhausted}`))
+      }
+    }
+    if (type === 'flow') {
+      if (s.prompt !== undefined) errors.push(err(target, 'flow 步骤不派发子代理,不可声明 prompt'))
+      if (s.outputs !== undefined || s.listOutputs !== undefined) errors.push(err(target, 'flow 步骤产出由子流程扁平挂载,不可声明 outputs/listOutputs'))
+      if (s.load !== undefined || s.for_each !== undefined || s.mode !== undefined) errors.push(err(target, 'flow 步骤不支持 load/for_each/mode'))
+      if (typeof s.flow !== 'string' || s.flow.trim() === '') errors.push(err(target, 'flow 步骤 flow 必填(模板 id 或 "{步骤id.产出名}" 动态路由)'))
+      else if (s.flow.trim() === t.id) errors.push(err(target, '子流程路由不可指向自身'))
+      if (s.input !== undefined) {
+        if (!isObj(s.input)) errors.push(err(target, 'input 须为对象'))
+        else for (const [k, v] of Object.entries(s.input)) {
+          if (typeof v !== 'string' || !/^\{[^{}]+\}$/.test(v)) errors.push(err(target, `input.${k} 须为单占位符引用 "{来源}"`))
+        }
+      }
+    }
+  }
+
+  // 占位符来源校验(prompt/flow/input 中 {引用} 的存在性与合法性)
+  const refOk = (s, ph, target) => {
+    if (ph === 'request') return true
+    if (ph === 'item' || ph === 'item.index') {
+      if (s.for_each === undefined) errors.push(err(target, `占位符 {${ph}} 仅在 for_each 步骤内可用`))
+      return
+    }
+    if (ph.startsWith('input.')) {
+      if (!declaredInputs.has(ph.slice(6))) errors.push(err(target, `占位符 {${ph}} 引用未声明的入参`))
+      return
+    }
+    const dot = ph.indexOf('.')
+    if (dot <= 0) {
+      errors.push(err(target, `占位符 {${ph}} 无合法来源(request/input.<name>/<步骤>.<产出>/item)`))
+      return
+    }
+    const refId = ph.slice(0, dot)
+    const refOut = ph.slice(dot + 1)
+    const ref = byId.get(refId)
+    if (!ref) {
+      errors.push(err(target, `占位符 {${ph}} 引用不存在的步骤`))
+      return
+    }
+    if (ref.type === 'approve') {
+      errors.push(err(target, `占位符 {${ph}} 不可引用审批步骤产出(裁决不进产出账)`))
+      return
+    }
+    const refOuts = isObj(ref.outputs) ? Object.keys(ref.outputs) : []
+    if (!refOuts.includes(refOut)) {
+      errors.push(err(target, `占位符 {${ph}} 的产出未在步骤 ${refId} outputs 中声明`))
+      return
+    }
+    if (refId === s.id && !(s.for_each !== undefined && s.mode === 'sequential')) {
+      errors.push(err(target, '自引用产出仅 sequential 循环实例可用(首实例解析空串)'))
+    }
+    const forbid = escalateTargetOf.get(s.id)
+    if (forbid !== undefined && refId === forbid) {
+      errors.push(err(target, `升级步占位符 {${ph}} 禁止引用审批对象产出(耗尽时已清空),只可引用其上游产出`))
+    }
+  }
+  for (const s of t.steps) {
+    if (!isObj(s) || typeof s.id !== 'string') continue
+    const target = `step:${s.id}`
+    if (typeof s.prompt === 'string') for (const ph of placeholdersOf(s.prompt)) refOk(s, ph, target)
+    if (type_flow(s)) {
+      const m = /^\{([^{}]+)\}$/.exec(String(s.flow).trim())
+      if (m) {
+        const ph = m[1]
+        if (!ph.includes('.') || ph.startsWith('input.') || ph === 'request' || ph === 'item') {
+          errors.push(err(target, `flow 动态路由 {${ph}} 须引用 "<步骤id>.<产出名>"`))
+        } else refOk(s, ph, target)
+      }
+      if (isObj(s.input)) for (const v of Object.values(s.input)) {
+        for (const ph of placeholdersOf(v)) refOk(s, ph, target)
+      }
+    }
+  }
+
+  // escalate-only 规则:不参与依赖图(不可声明 after),且不可被其他步骤 after 引用
+  for (const s of t.steps) {
+    if (!isObj(s) || typeof s.id !== 'string') continue
+    if (escalateTargetOf.has(s.id) && s.after !== undefined) {
+      errors.push(err(`step:${s.id}`, '升级步由引擎脱离常规调度图,不可声明 after'))
+    }
+  }
+  for (const s of t.steps) {
+    if (!isObj(s) || !Array.isArray(s.after)) continue
+    for (const dep of s.after) {
+      if (escalateTargetOf.has(dep)) errors.push(err(`step:${s.id}`, `after 不可引用升级步 ${dep}(其唯一触发边为审批耗尽)`))
+    }
+  }
+
+  // 环检测:边 = 显式 after,缺省 = 文档序前一步(escalate-only 无缺省边)
+  const depsOf = new Map()
+  t.steps.forEach((s, i) => {
+    if (!isObj(s) || typeof s.id !== 'string') return
+    let deps
+    if (Array.isArray(s.after)) deps = s.after
+    else if (escalateTargetOf.has(s.id) || i === 0) deps = []
+    else deps = [order[i - 1]]
+    depsOf.set(s.id, deps.filter((d) => byId.has(d) && d !== s.id))
+  })
+  const state = new Map()
+  const visit = (id, stack) => {
+    const st = state.get(id)
+    if (st === 'done') return
+    if (st === 'visiting') {
+      const cycle = [...stack.slice(stack.indexOf(id)), id].join(' -> ')
+      errors.push(err('top:steps', `依赖环:${cycle}`))
+      return
+    }
+    state.set(id, 'visiting')
+    for (const d of depsOf.get(id) ?? []) visit(d, [...stack, id])
+    state.set(id, 'done')
+  }
+  for (const id of depsOf.keys()) visit(id, [])
+
+  return errors
+}
+
+const type_flow = (s) => (s.type === undefined ? false : s.type === 'flow')
+
+// 集合校验:各模板单独校验 + 字面子流程引用存在性 + 嵌套深度 ≤3;损坏成员跳过不阻塞其余
+export function validateTemplateSet(list) {
+  const errors = []
+  const ok = []
+  for (const t of Array.isArray(list) ? list : []) {
+    const es = validateTemplate(t)
+    errors.push(...es)
+    if (es.length === 0) ok.push(t)
+  }
+  const ids = new Set(ok.map((t) => t.id))
+  const parsedById = new Map(ok.map((t) => [t.id, t]))
+  const tmplEdges = new Map()
+  for (const t of ok) {
+    const outs = new Set()
+    for (const s of t.steps) {
+      if (s.type !== 'flow' || typeof s.flow !== 'string') continue
+      const literal = s.flow.trim()
+      if (/^\{[^{}]+\}$/.test(literal)) continue
+      // 归属本模板(top:id 前缀):释放权威点按 id 过滤集合校验错误
+      if (!ids.has(literal)) errors.push(err('top:id', `${t.id} 步骤 ${s.id} 的子流程 ${literal} 不存在于模板集合`))
+      else {
+        if (literal !== t.id) outs.add(literal)
+        // 审批只在顶层可达:子模板含审批步则任何 flow 引用它的模板无法完成该子流程
+        const sub = parsedById.get(literal)
+        if (sub?.steps?.some((x) => x.type === 'approve')) errors.push(err('top:id', `${t.id} 引用的子流程 ${literal} 含审批步:审批仅支持顶层剧本`))
+      }
+    }
+    if (outs.size > 0) tmplEdges.set(t.id, outs)
+  }
+  const depthOf = (id, seen) => {
+    // 环即拒绝:深度无穷,不限于此路径是否重复经过
+    if (seen.has(id)) return Infinity
+    seen.add(id)
+    let d = 1
+    for (const n of tmplEdges.get(id) ?? []) d = Math.max(d, 1 + depthOf(n, seen))
+    return d
+  }
+  for (const id of tmplEdges.keys()) {
+    if (depthOf(id, new Set()) > MAX_NEST_DEPTH) errors.push(err(`top:id`, `${id} 子流程嵌套深度超过 ${MAX_NEST_DEPTH}`))
+  }
+  return errors
+}
+
+// 产出契约 → structured_output schema(宿主 schema 子集内);approve 步为固定裁决契约
+export function buildSchema(step) {
+  if (step.type === 'approve') return VERDICT_SCHEMA
+  const properties = {}
+  const required = []
+  const listSet = new Set(Array.isArray(step.listOutputs) ? step.listOutputs : [])
+  for (const name of Object.keys(isObj(step.outputs) ? step.outputs : {})) {
+    required.push(name)
+    properties[name] = listSet.has(name) ? { type: 'array', items: { type: 'string' } } : { type: 'string' }
+  }
+  return { type: 'object', required, additionalProperties: false, properties }
+}

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "@mzzsfy/dsh-rs-workflow",
-  "description": "若水工作流一体化:安装即得 rs-workflow agent 模式(协议技能、编排引擎、模式组合),含设置表单与工作流配置工具",
-  "version": "0.2.4",
+  "description": "若水工作流设置面:流程模板管理与工作位/预算配置(模板编辑/校验/配置读写)。编排运行时按 v5 设计(docs/rsww-v5/)另行实现。",
+  "version": "1.0.1",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
     ".": "./lib/index.js",
+    "./client": "./src/client.js",
     "./package.json": "./package.json"
   },
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web"
     }
   },
   "scripts": {
@@ -18,18 +22,18 @@
   },
   "license": "MIT",
   "repository": {
-    "type": "git",
+    "type": "object",
     "url": "git+https://github.com/mzzsfy/dsh-plugin.git"
   },
   "files": [
     "lib",
+    "src",
+    "engine",
     "preset",
     "cordis.patch.yml",
     "README.md"
   ],
   "peerDependencies": {
-    "@deepseek-ai/dsh-settings": ">=0.1.2-alpha.2",
-    "@deepseek-ai/dsh-tools": "^0.1.1-rc.2",
     "@deepseek-ai/schemastery": "^3.18.1"
   }
 }

package/preset/rs-workflow/agent.cordis.yml

@@ -1,32 +1,38 @@
-# The `rs-workflow` agent preset: 若水工作流。
+# The `rs-workflow` agent preset: 若水工作流(v5,主循环协作编排)。
 #
-# 迁移自 rs-tui (C:\Users\yuanhao\Desktop\jzjy\rscli) 的 rs-workflow 多模型协作工作流引擎。
-# 基底是 `standard` 全功能编码代理（本文件行集与出厂 standard 保持同构），
-# 差异有四处：
-#   1. persona 换成若水工作流纪律（非平凡需求走 workflow 编排）；
-#   2. skill-filesystem 追加预设自带技能目录 skills/（rs-workflow 协议技能随预设分发）；
-#   3. 追加 GUI 配置读取工具行 rs-workflow-config（@mzzsfy/dsh-rs-workflow
-#      的 tool 角色，裸包名从组合 baseUrl 上溯解析到 profile node_modules；
-#      GUI 表单注册在同包 settings 角色、bundle patch 行上；本文件整体由该包
-#      的 preset-sync 角色行释放到用户预设根，随插件安装/升级自动同步）；
-#   4. 其余行保持 standard 原样 —— 工具面不变，模式差异只由 persona + 技能承载。
+# 本文件是释放骨架源:release 生成器把它作为唯一源生成 rs-<id> 模式组合
+# (运行时仅改写 orchestrator 行的 templateId 锚定),不在包内被宿主装载。
 #
-# 平面规则与 standard 一致：本文件是 AGENT-PLANE 组合；服务行必须在 isolate realm 后面。
+# 基底是 `standard` 全功能编码代理行集,差异:
+#   1. persona 换成流程模式纪律 v5(人机接口+受约束规划者,任务交付由编排子代理承担);
+#   2. delegation 组内 rs-workflow-orchestrator 工具行与 template-tool 行;
+#   3. 无 report 行(trace 事件 + run-store 取代);plan-mode 组移除(规划在编排内)。
 
 # ── identity ────────────────────────────────────────────────────────────────
 
 - id: persona
   name: '@deepseek-ai/dsh-persona'
   config:
-    text: |-
-      你是"若水工作流"编码 Agent，由 {{model}} 模型驱动，工作目录 {{cwd}}。
-      本模式迁移自 rs-tui 的多模型协作工作流引擎：executor 执行、reviewer 审批、planner 规划分诊，模型间分工与相互制约。
-
-      核心纪律：
-      - 非平凡编码需求（多步骤、多文件、质量敏感或有回归风险）必须先加载 rs-workflow 技能，按其协议用 workflow 工具启动编排：分诊与规划 → 执行与审批 → 终审，必要时升级重规划。
-      - 琐碎请求（问答、解释、单点小改）直接处理，不空转流程（off 态）。用户点名模板（lite / plan-final / step-review / multi-plan）时锁定该模板。
-      - 各角色的模型由工作位（slot）配置决定：细分位缺失降级基础位，再降级会话默认模型；配置以 GUI 设置页 rs-workflow 段为准（启动编排前用 rs_workflow_config 工具读取，改后即时生效），工具不可用时回退技能目录的 slots.json5。
-      - 工作流结束后必须向用户完整汇报：模板、难度分诊、任务结果、审批结论、变更文件；blocked 时说明原因并给出建议。
+    prefix: |-
+      你是"若水工作流"会话代理,由 {{model}} 模型驱动。你负责人机协作与编排调度;
+      任务交付由流程引擎接管下的子代理完成,你不直接产出交付物。
+      职责判据:
+      1. 纯会话内请求(问答、解释、讨论,不产生文件)→ 直接答复,不起编排;
+      2. 凡需新建或修改交付物文件(代码、页面、脚本、文档、配置,无论大小与步骤数,例如"写个贪吃蛇html")
+         → 必须调用 rs_workflow_start,提交结构化规划(steps 各步要点与验收口径);禁止以"一句话能答、
+         改动小"为由绕开编排自行产出文件;此通道无豁免:规划被拒按 errors 修正重交,不许改道自行完成;
+      3. 编排运行中你只被段结束通知或用户消息唤醒:任一唤醒轮先 rs_workflow_status 检查现役 run——
+         status=running 且无活跃段 job(待拉起)或 status=paused 且 awaitingResume=true(页签已发恢复)
+         时,即 rs_workflow_resume 补拉;waiting_approval 一律不补拉,轮到裁决:按模板 autoApprove 决定
+         代审或 ask_user 转呈真人,裁决经 rs_workflow_verdict 回写(autoApprove 代审 by 缺省,转呈真人
+         by=user,意见必填),裁决受理后 rs_workflow_resume 拉起下一段;
+         终态则汇报(完成经 deliverables 交付,汇报必须引用 runId 供页签核验;失败/阻塞说明卡点与建议);
+         任何交付说明若无对应 run 记录即为违规——禁止把自行产出的文件当交付物汇报;
+         用户中途纠偏经 rs_workflow_message 注入,下一步骤边界进入编排;
+      4. 你不代替子代理执行编排内步骤,不伪造产出,不跳过引擎直接交付;
+      5. 引擎不可用或编排启动失败时,不得自行完成文件类请求——向用户说明故障与已尝试的调用,
+         等待用户处置;文件交付只有 rs_workflow_ 通道,没有自行兜底。
+    suffix: Your working directory is {{cwd}}.
 
 - id: agent-instructions
   name: '@deepseek-ai/dsh-agent-instructions'
@@ -35,7 +41,10 @@
 
 # ── shell ───────────────────────────────────────────────────────────────────
 
-# 与 standard 相同：两个 shell 工具消费 HOST 侧注册表，执行器也在 host 平面。
+# 注:不可禁本组合 shell/fs 工具行——宿主 workflow worker 的段子代理继承组合行集,
+# 禁行使段子代理无法落盘交付物(实测证实)。主循环不写文件由 persona 判据约束,
+# 物理隔离需宿主提供 worker 行集覆写能力(外部依赖)。
+
 - id: tool-bash
   name: '@deepseek-ai/dsh-tool-bash'
   disabled: !!js process.platform === 'win32'
@@ -61,60 +70,23 @@
 
 # ── skills ──────────────────────────────────────────────────────────────────
 
-# 与 cordis 出厂预设相同的手法：customSkillDirs 指向预设自己的 skills/ 目录，
-# baseUrl 即预设目录本身，因此 rs-workflow 协议技能随预设安装、复制、迁移。
 - id: skill-filesystem
   name: '@deepseek-ai/dsh-skill-filesystem'
-  config:
-    customSkillDirs:
-      - !!js "process.getBuiltinModule('node:url').fileURLToPath(new URL('skills/', baseUrl))"
 
 - id: tool-skill
   name: '@deepseek-ai/dsh-tool-skill'
 
-# 若水工作流的 GUI 配置读取工具（rs_workflow_config）：主代理启动编排前调用。
-# 包本体由 `dsh plugin add @mzzsfy/dsh-rs-workflow` 安装进 profile node_modules；
-# 本 preset 文件由同包的 preset-sync 角色行在宿主启动时释放/同步到用户预设根。
-# 预设行的裸包名从组合 baseUrl（profile 目录）上溯解析；settings 表单的注册
-# 在同包 bundle patch 行上（见包内 cordis.patch.yml）。
-- id: rs-workflow-config
-  name: '@mzzsfy/dsh-rs-workflow'
-  config:
-    role: tool
-
-# ── goals ───────────────────────────────────────────────────────────────────
-
-- id: tool-goal
-  name: '@deepseek-ai/dsh-tool-goal'
+# ── web ─────────────────────────────────────────────────────────────────────
 
-# ── plan mode ───────────────────────────────────────────────────────────────
-
-# 保留 standard 的计划模式：用户仍可把会话切到 plan 模式做前置规划，
-# 与工作流不冲突（工作流自身的规划发生在编排内部）。
-- id: planning
-  name: cordis:group
-  group: true
-  isolate:
-    planMode: true
+- id: tool-web
+  name: '@deepseek-ai/dsh-tool-web'
   config:
-    - id: plan-mode
-      name: '@deepseek-ai/dsh-plan-mode'
-      config:
-        section: |
-              You are in plan mode. Stay in plan mode until exit_plan_mode succeeds or the user switches the session mode. Imperative language to implement changes means plan the implementation, not execute it. A user's conversational agreement — including an answer confirming something you asked — approves nothing and does not end plan mode; fold the confirmed decision into the plan and submit it through exit_plan_mode.
-
-              Explore first. Use non-mutating reads, searches, static analysis, and checks to ground the plan in the actual repository. Do not edit or write files, change configuration, run formatters or code generation that rewrites tracked files, commit, or otherwise carry out the plan. Prefer existing functions and patterns over new machinery.
-
-              The tool catalog stays the same across modes for request-cache stability. These plan-mode rules override any later tool description or guidance that suggests using mutation tools; those tools remain listed to keep the tool catalog unchanged. Do not use todo_write to track this planning phase: it tracks implementation after an approved plan, while the plan itself belongs in exit_plan_mode.
-
-              Resolve discoverable facts by inspection. Use ask_user_question only for user-owned choices or material ambiguity that inspection cannot answer. Do not ask the user where code lives or how current behavior works when you can find out.
-
-              Make the plan decision-complete: state the goal and success criteria; group implementation changes by subsystem; identify public API, schema, and data-flow changes; cover edge cases, failure modes, tests, acceptance criteria, and explicit assumptions. Keep it concise enough to review but detailed enough that another engineer can implement it without making design decisions.
-
-              When ready, call exit_plan_mode with the complete plan markdown, starting with a # title. Make exit_plan_mode the only and final tool call in that assistant response: it presents the plan for approval, and implementation begins only in a later step after approval. Do not paste the final plan as a plain reply or ask "should I proceed?" through prose or ask_user_question. If review rejects it, incorporate the feedback and present again. If the review channel is unavailable or aborted, stay in plan mode and ask the user to switch modes manually; do not proceed with implementation.
+    fetch: false
+    searchTimeoutMs: 60000
 
 # ── compaction ──────────────────────────────────────────────────────────────
 
+# 编排子代理上下文较长,保留 standard 的压缩组。
 - id: compaction
   name: cordis:group
   group: true
@@ -137,8 +109,10 @@
 
 # ── delegation and workflows ────────────────────────────────────────────────
 
-# 与 standard 相同：subagents 注册表留在 HOST；workflowEngine 是预设私有服务，
-# 所有触达它的行共享一个 entry-local realm。
+# workflowEngine 是预设私有服务(preset 组合发布全局服务会被宿主拒绝 mount),
+# 所有触达它的行共享一个 entry-local isolate realm。
+# orchestrator 行注册 rs_workflow_* 六工具(含裁决回写 rs_workflow_verdict)并经 jobs 服务拉起分段 continuable job;
+# 控制队列与 store 为普通模块单例,host/agent 行经同一 realpath 解析共享实例。
 - id: delegation
   name: cordis:group
   group: true
@@ -179,6 +153,19 @@
         subagentProvider: spawn
         maxRounds: 64
 
+    # orchestrator 工具行:模板 id 由组合名承载(rs-<id> → <id>),释放生成器按组合名写入
+    - id: rs-workflow-orchestrator
+      name: '@mzzsfy/dsh-rs-workflow'
+      config:
+        role: orchestrator
+        templateId: TPL_ANCHOR
+
+    # 模板编辑工具行:rs_workflow_template(AI 按口述逻辑生成/修改流程模板)
+    - id: rs-workflow-template-tool
+      name: '@mzzsfy/dsh-rs-workflow'
+      config:
+        role: template-tool
+
 # ── remaining model-facing rows ─────────────────────────────────────────────
 
 - id: tool-ask-user
@@ -188,9 +175,3 @@
   name: '@deepseek-ai/dsh-tool-todo'
   config:
     allowParallelInProgress: true
-
-- id: tool-web
-  name: '@deepseek-ai/dsh-tool-web'
-  config:
-    fetch: false
-    searchTimeoutMs: 60000

package/preset/rs-workflow/preset.yml

@@ -1,5 +1,5 @@
-name: 若水工作流
+name: 若水·流程编排 v5
 description: >-
-  rs-tui 多模型协作工作流迁移版：planner/executor/reviewer 三角色子代理分工，
-  难度分诊四模板（lite / plan-final / step-review / multi-plan），
-  审批循环、升级重规划与工作位模型降级链；非平凡编码需求自动走工作流编排。
+  若水工作流 v5:简单请求直接答复,复杂请求经结构化规划进入流程编排;
+  主模型作为人机接口与受约束规划者,任务交付由引擎子代理分段完成;
+  审批可代审可转呈,运行中消息注入纠偏,取消即时生效,产出与重跑/续跑在会话页签全量可查。