/** * 创作流程 parse / validate / catalog / recipes */ import { describe, expect, it } from "vitest"; import { artifactTagForStep, extractModuleOpening, formatCreationFlowForUser, deriveFlowStepTitle, titleFromSuggestion, formatFlowProgressForAgent, listCallableCatalogModules, formatModuleCatalogForAgent, formatModuleCatalogForDictate, catalogModulesForIntake, formatRecipeCatalogForAgent, formatDictateRecipeBrief, formatRecipeExamplesForCreationPlan, formatSelectedRecipeForAgent, isCreationFlowComplete, loadAllRecipeDetails, loadModuleCatalog, loadModulePrompt, loadRecipeCatalog, loadRecipeDetail, mergeCreationFlowPreservingAccepted, needsFlowExpansion, nextPendingStep, listReadySteps, computeStepLayers, spawnRepeatableCreationStep, repeatableInstanceProductTag, spawnInstanceFromPrototype, hasSelectableCreationWork, hasAcceptedCloserStep, removeUnstartedInstance, removeRepeatableInstance, pruneRepeatableArtifactContent, looksLikeCreationFlowDoc, parseCreationFlow, pickRecordedStepId, parseModuleCatalog, parseModuleOpeningState, parseRecipeCatalog, parseRecipeYaml, parseSelectedRecipeRef, resolveDesignStepBinding, isProgressPointerTag, stringifyCreationFlow, stripReviseSteps, creationFlowFromRecipeSeed, validateCreationFlow, validateStepReadyToRun, } from "../src/skills/creation-flow.js"; import { loadWorkerSkillWithContext } from "../src/skills/loader.js"; const sampleCatalog = parseModuleCatalog(` modules: - name: 美学纲领与交互范式 declaration: 站位与体验契约 artifact: 设计.美学纲领与交互范式 - name: 实现机制 declaration: worker 与表 artifact: 设计.实现机制 - name: 生成规则 declaration: 可执行规则 artifact: 设计.生成规则 repeatable: true - name: 具体实例 declaration: 锚定实例 artifact: 设计.具体实例 repeatable: true - name: 开场白与开场变量 declaration: 收口 artifact: 设计.开场白与开场变量 closer: true `)!; describe("creation-flow", () => { it("parses minimal flow JSON and fills step ids", () => { const flow = parseCreationFlow(`{ "brief": "单角代入", "steps": [ { "name": "美学纲领与交互范式", "depends_on": [] } ] }`); expect(flow).toEqual({ version: 1, brief: "单角代入", status: undefined, steps: [ { id: "美学纲领与交互范式", name: "美学纲领与交互范式", depends_on: [], }, ], }); }); it("keeps accepted steps intact when the planner rewrites the flow", () => { const prev = `{ "status": "open", "steps": [ { "id": "美学纲领与交互范式", "name": "美学纲领与交互范式", "depends_on": [] } ] }`; const rewritten = `{ "status": "open", "steps": [ { "id": "美学纲领与交互范式", "name": "美学纲领与交互范式", "depends_on": ["实现机制"] }, { "id": "实现机制", "name": "实现机制", "depends_on": [] } ] }`; const merged = mergeCreationFlowPreservingAccepted({ prevRaw: prev, nextRaw: rewritten, acceptedStepIds: ["美学纲领与交互范式"], }); expect(merged.restored).toEqual(["美学纲领与交互范式"]); const flow = parseCreationFlow(merged.raw)!; expect(flow.steps[0]?.depends_on).toEqual([]); expect(flow.steps.map((s) => s.id)).toEqual([ "美学纲领与交互范式", "实现机制", ]); }); it("re-inserts an accepted step the planner dropped", () => { const prev = `{ "status": "open", "steps": [ { "id": "美学纲领与交互范式", "name": "美学纲领与交互范式", "depends_on": [] } ] }`; const rewritten = `{ "status": "open", "steps": [{ "id": "实现机制", "name": "实现机制", "depends_on": [] }] }`; const merged = mergeCreationFlowPreservingAccepted({ prevRaw: prev, nextRaw: rewritten, acceptedStepIds: ["美学纲领与交互范式"], }); expect(parseCreationFlow(merged.raw)!.steps.map((s) => s.id)).toEqual([ "美学纲领与交互范式", "实现机制", ]); }); it("leaves an untouched rewrite alone", () => { const prev = `{ "status": "open", "steps": [ { "id": "美学纲领与交互范式", "name": "美学纲领与交互范式", "depends_on": [] } ] }`; const rewritten = `{ "status": "open", "steps": [ { "id": "美学纲领与交互范式", "name": "美学纲领与交互范式", "depends_on": [] }, { "id": "实现机制", "name": "实现机制", "depends_on": ["美学纲领与交互范式"] } ] }`; const merged = mergeCreationFlowPreservingAccepted({ prevRaw: prev, nextRaw: rewritten, acceptedStepIds: ["美学纲领与交互范式"], }); expect(merged.restored).toEqual([]); expect(parseCreationFlow(merged.raw)!.steps.map((s) => s.id)).toEqual([ "美学纲领与交互范式", "实现机制", ]); }); it("drops planner revise steps when merging flow", () => { const prev = `{ "status": "open", "steps": [ { "id": "美学纲领与交互范式", "name": "美学纲领与交互范式", "depends_on": [] } ] }`; const rewritten = `{ "status": "open", "steps": [ { "id": "美学纲领与交互范式", "name": "美学纲领与交互范式", "depends_on": [] }, { "id": "美学纲领与交互范式·改", "name": "美学纲领与交互范式", "mode": "revise", "revises": "美学纲领与交互范式", "depends_on": ["美学纲领与交互范式"] }, { "id": "实现机制", "name": "实现机制", "depends_on": ["美学纲领与交互范式·改"] } ] }`; const merged = mergeCreationFlowPreservingAccepted({ prevRaw: prev, nextRaw: rewritten, acceptedStepIds: ["美学纲领与交互范式"], }); const flow = parseCreationFlow(merged.raw)!; expect(flow.steps.map((s) => s.id)).toEqual([ "美学纲领与交互范式", "实现机制", ]); expect(flow.steps[1]?.depends_on).toEqual(["美学纲领与交互范式"]); }); it("allows duplicate capability names with distinct ids", () => { const flow = parseCreationFlow(`{ "status": "open", "steps": [ { "id": "生成规则", "name": "生成规则", "depends_on": [] }, { "id": "生成规则#2", "name": "生成规则", "depends_on": ["生成规则"] }, { "id": "具体实例", "name": "具体实例", "depends_on": ["生成规则#2"] } ] }`)!; expect(flow.status).toBe("open"); expect(flow.steps.map((s) => s.id)).toEqual([ "生成规则", "生成规则#2", "具体实例", ]); expect(validateCreationFlow(flow, sampleCatalog).ok).toBe(true); }); it("auto-numbers duplicate names when id omitted", () => { const flow = parseCreationFlow(`{ "steps": [ { "name": "生成规则", "depends_on": [] }, { "name": "生成规则", "depends_on": ["生成规则"] } ] }`)!; expect(flow.steps[0]?.id).toBe("生成规则"); expect(flow.steps[1]?.id).toBe("生成规则#2"); expect(validateCreationFlow(flow, sampleCatalog).ok).toBe(true); }); it("extracts JSON from surrounding text", () => { const flow = parseCreationFlow( `说明如下\n{"steps":[{"name":"美学纲领与交互范式","depends_on":[]}]}\n完`, ); expect(flow?.steps[0]?.name).toBe("美学纲领与交互范式"); }); it("extracts JSON from a code fence", () => { const flow = parseCreationFlow( "```json\n{\"brief\":\"单角代入\",\"steps\":[{\"name\":\"美学纲领与交互范式\",\"depends_on\":[]}]}\n```", ); expect(flow?.brief).toBe("单角代入"); expect(flow?.steps[0]?.name).toBe("美学纲领与交互范式"); }); it("recognizes a DAG object and ignores brief-only objects", () => { expect( looksLikeCreationFlowDoc({ brief: "单角代入", steps: [{ name: "美学纲领与交互范式", depends_on: [] }], }), ).toBe(true); expect(looksLikeCreationFlowDoc({ brief: "单角代入" })).toBe(false); }); it("validates deps must appear earlier", () => { const bad = parseCreationFlow(`{ "steps": [ { "name": "实现机制", "depends_on": ["美学纲领与交互范式"] }, { "name": "美学纲领与交互范式", "depends_on": [] } ] }`)!; const result = validateCreationFlow(bad, sampleCatalog); expect(result.ok).toBe(false); expect(result.errors.some((e) => e.includes("未排在其前面"))).toBe(true); }); it("rejects unknown module names when catalog given", () => { const flow = parseCreationFlow(`{ "steps": [{ "name": "不存在的工序", "depends_on": [] }] }`)!; const result = validateCreationFlow(flow, sampleCatalog); expect(result.ok).toBe(false); expect(result.errors[0]).toContain("不在模块目录"); }); it("rejects non-repeatable duplicate names", () => { const flow = parseCreationFlow(`{ "steps": [ { "name": "实现机制", "depends_on": [] }, { "id": "实现机制#2", "name": "实现机制", "depends_on": ["实现机制"] } ] }`)!; const result = validateCreationFlow(flow, sampleCatalog); expect(result.ok).toBe(false); expect(result.errors.some((e) => e.includes("repeatable"))).toBe(true); }); it("accepts a valid ordered flow", () => { const flow = parseCreationFlow(`{ "steps": [ { "name": "美学纲领与交互范式", "depends_on": [] }, { "name": "实现机制", "depends_on": ["美学纲领与交互范式"] } ] }`)!; expect(validateCreationFlow(flow, sampleCatalog).ok).toBe(true); expect(artifactTagForStep("美学纲领与交互范式", sampleCatalog)).toBe( "设计.美学纲领与交互范式", ); }); it("formats user view without English tags", () => { const flow = parseCreationFlow(`{ "brief": "网恋回合", "status": "open", "steps": [ { "name": "美学纲领与交互范式", "depends_on": [] }, { "name": "生成规则", "depends_on": ["美学纲领与交互范式"] }, { "id": "生成规则#2", "name": "生成规则", "depends_on": ["生成规则"] } ] }`)!; const view = formatCreationFlowForUser(flow, sampleCatalog); expect(view.brief).toBe("网恋回合"); expect(view.status).toBe("open"); expect(view.steps[0]).toMatchObject({ order: 1, name: "美学纲领与交互范式", depends_on: [], declaration: "站位与体验契约", }); expect(view.steps[2]?.role).toBe("instance"); expect(view.steps[2]?.occurrence).toBe(1); expect(view.steps[1]?.role).toBe("prototype"); expect(view.steps[2]?.repeatable).toBe(true); expect(view.steps[0]?.runState).toBe("pending"); expect(view.steps[0]?.layer).toBe(0); expect(view.steps[0]?.ready).toBe(true); expect(view.steps[0]?.selectable).toBe(true); expect(view.availableModules?.map((m) => m.name)).toEqual([ "实现机制", "具体实例", "开场白与开场变量", ]); expect(view.steps[1]?.runState).toBe("pending"); expect(view.steps[1]?.layer).toBe(1); expect(view.steps[1]?.ready).toBe(false); expect(view.steps[2]?.runState).toBe("pending"); }); it("shows a short title for 生成规则 / 具体实例 prototypes and instances", () => { const flow = parseCreationFlow(`{ "steps": [ { "id": "生成规则", "name": "生成规则", "role": "prototype", "suggestion": "幸存者生成规则：锚定出租屋内的女性租客", "depends_on": [] }, { "id": "生成规则#1", "name": "生成规则", "role": "instance", "from": "生成规则", "depends_on": [] }, { "id": "具体实例", "name": "具体实例", "role": "prototype", "suggestion": "按幸存者规则生成开局女租客", "depends_on": ["生成规则"] }, { "id": "具体实例#1", "name": "具体实例", "role": "instance", "from": "具体实例", "params": { "batch_goal": "开局女租客", "rule_id": "survivors" }, "depends_on": ["生成规则#1"] } ] }`)!; const untitled = formatCreationFlowForUser(flow, sampleCatalog); expect(untitled.steps.find((s) => s.id === "生成规则")?.title).toBe( "幸存者生成规则", ); expect(untitled.steps.find((s) => s.id === "生成规则#1")?.title).toBe( "幸存者生成规则", ); expect(untitled.steps.find((s) => s.id === "具体实例")?.title).toBe( "按幸存者规则生成开局女租客", ); expect(untitled.steps.find((s) => s.id === "具体实例#1")?.title).toBe( "开局女租客", ); const accepted = formatCreationFlowForUser(flow, sampleCatalog, [], [], { "生成规则#1": { summary: "生成规则 · 幸存者 · 预生成并动态" }, "具体实例#1": { summary: "具体实例 · 女租客 · 2条" }, }); expect(accepted.steps.find((s) => s.id === "生成规则#1")?.title).toBe( "幸存者", ); expect(accepted.steps.find((s) => s.id === "具体实例#1")?.title).toBe( "女租客", ); expect( deriveFlowStepTitle({ name: "生成规则", hint: { content: { 正文: { 本步参数: { target: "女租客" } }, }, }, }), ).toBe("女租客"); expect(titleFromSuggestion("怪物生成规则：按族群抽样")).toBe( "怪物生成规则", ); }); it("marks accepted steps done and the next pending current", () => { const flow = parseCreationFlow(`{ "brief": "网恋回合", "status": "open", "steps": [ { "name": "美学纲领与交互范式", "depends_on": [] }, { "name": "生成规则", "depends_on": ["美学纲领与交互范式"] }, { "id": "生成规则#2", "name": "生成规则", "depends_on": ["生成规则"] } ] }`)!; const view = formatCreationFlowForUser(flow, sampleCatalog, [ "美学纲领与交互范式", ]); expect(view.steps.map((s) => s.runState)).toEqual([ "done", "pending", "pending", ]); expect(view.steps[1]?.selectable).toBe(true); }); it("loads world-simulator catalog and formats for agent", async () => { const catalog = await loadModuleCatalog("dialogue/world-simulator"); expect(catalog?.modules.some((m) => m.name === "美学纲领与交互范式")).toBe( true, ); expect(catalog?.modules.some((m) => m.name === "主角设定")).toBe(true); expect(catalog?.modules.some((m) => m.name === "交互范式")).toBe(false); expect(catalog?.modules.some((m) => m.name === "美学纲领")).toBe(false); expect( catalog?.modules.find((m) => m.name === "生成规则")?.repeatable, ).toBe(true); expect( catalog?.modules.find((m) => m.name === "具体实例")?.repeatable, ).toBe(true); expect( catalog?.modules.find((m) => m.name === "生成规则")?.kind, ).toBe("prior-artifact"); expect( catalog?.modules.find((m) => m.name === "具体实例")?.kind, ).toBe("prior-artifact"); expect( catalog?.modules.find((m) => m.name === "生成规则")?.params?.[0]?.key, ).toBe("target"); expect( catalog?.modules.find((m) => m.name === "具体实例")?.params?.[0]?.key, ).toBe("rule_id"); expect( catalog?.modules.find((m) => m.name === "上下文排序")?.auto, ).toBe(true); const gen = catalog?.modules.find((m) => m.name === "生成规则"); expect(gen?.when).toBeTruthy(); expect(gen?.when_not).toBeTruthy(); expect(gen?.boundary).toBeTruthy(); const block = formatModuleCatalogForAgent(catalog!); expect(block).toContain("【能力"); expect(block).toContain("美学纲领与交互范式："); expect(block).toContain("生成规则〔可反复〕〔先验产物〕"); expect(block).toContain("上下文排序〔程序步〕"); expect(block).toContain("何时用"); expect(block).toContain("何时不用"); expect(block).toContain("role=prototype"); expect(block).toContain("编排参数"); expect(block).not.toContain("设计.美学纲领与交互范式"); expect(block).toContain("- 叙事指南与故事推进："); expect(block).not.toMatch(/^- 叙事指南：/m); expect(block).not.toMatch(/^- 故事推进：/m); const dictateBlock = formatModuleCatalogForDictate(catalog!); expect(dictateBlock).toMatch(/^- 叙事指南：/m); expect(dictateBlock).toMatch(/^- 故事推进：/m); expect(dictateBlock).toContain("开场白与开场变量〔可反复〕〔收口〕"); expect(dictateBlock).toContain("信息可见范围〔落档程序〕"); expect(dictateBlock).not.toMatch(/^- 叙事指南与故事推进/m); expect( catalog?.modules.find((m) => m.name === "叙事指南与故事推进")?.intake, ).toBe("recipe"); expect(catalog?.modules.find((m) => m.name === "叙事指南")?.intake).toBe( "dictate", ); expect(catalog?.modules.find((m) => m.name === "故事推进")?.intake).toBe( "dictate", ); expect(catalog?.modules.find((m) => m.name === "故事推进")?.libraries).toEqual([ "preferences", ]); expect(catalog?.modules.some((m) => m.id === "user-requirements")).toBe(false); expect( catalog?.modules.find((m) => m.name === "叙事指南")?.libraries, ).toEqual(["style-packs"]); expect( catalog?.modules.find((m) => m.name === "叙事指南与故事推进")?.libraries, ).toEqual(["style-packs"]); expect(dictateBlock).not.toContain("【偏好库 · 可选用】"); expect( catalogModulesForIntake(catalog!, "recipe").some( (m) => m.name === "叙事指南", ), ).toBe(false); expect( catalogModulesForIntake(catalog!, "dictate").some( (m) => m.name === "叙事指南与故事推进", ), ).toBe(false); const leftover = listCallableCatalogModules({ catalog: catalog! }); expect(leftover.some((m) => m.name === "叙事指南与故事推进")).toBe(true); expect(leftover.some((m) => m.name === "叙事指南")).toBe(false); expect(leftover.some((m) => m.name === "故事推进")).toBe(false); const splitFlow = parseCreationFlow(`{ "steps": [{ "name": "叙事指南", "depends_on": [] }] }`)!; expect(validateCreationFlow(splitFlow, catalog).ok).toBe(false); }); it("loads recipe catalog for user director selection UI", async () => { const recipes = await loadRecipeCatalog("dialogue/world-simulator"); expect(recipes?.recipes.some((r) => r.name === "回合推演")).toBe(true); expect(recipes?.recipes.some((r) => r.name === "扩写助手")).toBe(true); expect(recipes?.recipes.some((r) => r.name === "文本生成器")).toBe(false); const block = formatRecipeCatalogForAgent(recipes!); expect(block).toContain("须由用户手动选择"); expect(block).toContain("回合推演"); const details = await loadAllRecipeDetails("dialogue/world-simulator"); expect(details.length).toBeGreaterThanOrEqual(2); const ws = details.find((d) => d.id === "world-simulator"); expect(ws?.when).toBeTruthy(); expect(ws?.core).toBeTruthy(); expect(ws?.process).toBeTruthy(); expect(ws?.principles).toBeTruthy(); expect( ws?.seed?.steps.some((s) => s.name === "美学纲领与交互范式"), ).toBe(true); expect(ws?.seed?.status).toBe("open"); const formatted = formatSelectedRecipeForAgent(ws!); expect(formatted).toContain("核心思路"); expect(formatted).toContain("设计流程"); expect(formatted).toContain("原则"); expect(formatted).not.toContain("调味提示"); }); it("loads dictate recipe catalog separately with Chinese ids", async () => { const dictate = await loadRecipeCatalog( "dialogue/world-simulator", undefined, "dictate", ); expect(dictate?.recipes.some((r) => r.id === "文本生成器")).toBe(true); expect(dictate?.recipes.some((r) => r.name === "文本生成器")).toBe(true); expect(dictate?.recipes.some((r) => r.name === "交互式长文生成器")).toBe(true); expect(dictate?.recipes.some((r) => r.name === "数据化跑团体验")).toBe(true); expect(dictate?.recipes.some((r) => r.id === "快穿短局")).toBe(true); expect(dictate?.recipes.some((r) => r.name === "快穿短局")).toBe(true); expect(dictate?.recipes.some((r) => r.id === "正文组成")).toBe(false); expect(dictate?.recipes).toHaveLength(4); expect(dictate?.recipes[0]?.id).toBe("快穿短局"); const entry = dictate!.recipes.find((r) => r.id === "文本生成器")!; expect(entry.family).toBe("dictate"); const detail = await loadRecipeDetail("dialogue/world-simulator", entry); expect(detail.method?.join("")).toMatch(/范例|写法|输入/); expect(detail.tierTendencies?.some((item) => item.module_id === "narrative-guide")).toBe(true); expect(detail.seed).toBeNull(); const longform = dictate!.recipes.find((r) => r.id === "交互式长文生成器")!; const longDetail = await loadRecipeDetail("dialogue/world-simulator", longform); expect(longDetail.brief).toMatch(/长连续/); expect(longDetail.method?.join("")).toMatch(/变量|动态表/); expect(longDetail.method?.join("")).toMatch(/硬机制|数据化跑团/); const rpg = dictate!.recipes.find((r) => r.id === "数据化跑团体验")!; const rpgDetail = await loadRecipeDetail("dialogue/world-simulator", rpg); expect(rpgDetail.brief).toMatch(/硬判断|结构化状态/); expect(rpgDetail.method?.join("")).toMatch(/长短|连续性/); expect(rpgDetail.tierTendencies?.some((item) => item.module_id === "mechanism")).toBe(true); const skip = dictate!.recipes.find((r) => r.id === "快穿短局")!; const skipDetail = await loadRecipeDetail("dialogue/world-simulator", skip); expect(skipDetail.seed).toBeNull(); expect(skipDetail.brief).toMatch(/体验核|短反馈/); expect(skipDetail.signals?.join("")).toMatch(/快穿|一次性|短任务/); const examples = formatRecipeExamplesForCreationPlan([ detail, longDetail, rpgDetail, skipDetail, ]); expect(examples).toContain("适用信号"); expect(examples).toContain("档位倾向"); expect(examples).toContain("variable-design=有必要"); expect(examples).not.toContain("固定路径"); }); it("parses selected recipe ref", () => { expect(parseSelectedRecipeRef("world-simulator")).toBe("world-simulator"); expect(parseSelectedRecipeRef('{"id":"expand-assistant","name":"扩写助手"}')).toBe( "expand-assistant", ); expect(parseSelectedRecipeRef("")).toBeNull(); }); it("parses recipe yaml with methodology fields", () => { const detail = parseRecipeYaml( ` when: 测试适用 core: 核心一句话 process: - 先美学 - 再按缺口选型 principles: - 正推 brief: 测试 brief steps: - name: 美学纲领与交互范式 depends_on: [] `, { id: "t", name: "测试配方", declaration: "测" }, ); expect(detail.when).toBe("测试适用"); expect(detail.core).toContain("核心一句话"); expect(detail.process).toEqual(["先美学", "再按缺口选型"]); expect(detail.principles).toEqual(["正推"]); expect(detail.seed?.status).toBe("open"); expect(detail.seed?.steps).toEqual([ { id: "美学纲领与交互范式", name: "美学纲领与交互范式", depends_on: [], }, ]); const formatted = formatSelectedRecipeForAgent(detail); expect(formatted).toContain("用户已选配方"); expect(formatted).toContain("核心思路"); expect(formatted).toContain("开局 steps"); const seeded = creationFlowFromRecipeSeed(detail); expect(seeded?.steps[0]?.name).toBe("美学纲领与交互范式"); expect(seeded?.status).toBe("open"); const raw = stringifyCreationFlow(seeded!); expect(parseCreationFlow(raw)?.steps[0]?.id).toBe("美学纲领与交互范式"); expect(creationFlowFromRecipeSeed({ seed: null })).toBeNull(); expect( creationFlowFromRecipeSeed({ seed: { version: 1, status: "open", steps: [] }, }), ).toBeNull(); }); it("creationFlowFromRecipeSeed follows the recipe steps, not a fixed first node", () => { const detail = parseRecipeYaml( ` when: 其它剧本 steps: - name: 舞台骨架 depends_on: [] - name: 实现机制 depends_on: ["舞台骨架"] `, { id: "other", name: "其它", declaration: "测" }, ); const seeded = creationFlowFromRecipeSeed(detail); expect(seeded?.steps.map((s) => s.name)).toEqual(["舞台骨架", "实现机制"]); }); it("falls back to legacy hint when methodology absent", () => { const detail = parseRecipeYaml( ` when: 旧配方 hint: 可调味 steps: - name: 美学纲领与交互范式 depends_on: [] `, { id: "legacy", name: "旧", declaration: "测" }, ); expect(detail.hint).toBe("可调味"); expect(formatSelectedRecipeForAgent(detail)).toContain("调味提示（旧字段）"); }); it("parseRecipeCatalog skips incomplete rows", () => { const cat = parseRecipeCatalog(` recipes: - id: ok name: 好配方 declaration: 有声明 - id: bad name: 缺声明 `); expect(cat?.recipes).toEqual([ { id: "ok", name: "好配方", declaration: "有声明", family: "recipe" }, ]); }); it("injects selected recipe into design-flow", async () => { const selected = await loadWorkerSkillWithContext( "world-simulator", "design-flow", undefined, { selectedRecipeRef: "world-simulator" }, ); expect(selected.worker.outputTags).toContain("设计.创作流程"); expect(selected.promptBody).toContain("【用户已选配方 · 回合推演】"); expect(selected.promptBody).toContain("回合推演"); expect(selected.promptBody).toContain("【能力"); expect(selected.promptBody).toContain("美学纲领与交互范式"); expect(selected.promptBody).toContain("核心思路"); expect(selected.promptBody).toContain("何时用"); expect(selected.promptBody).toContain("开局 steps"); expect(selected.promptBody).toContain("【流程进度】"); expect(selected.promptBody).not.toContain("用户尚未手动选择"); }); it("tells design-flow which steps are done and not to reschedule them", async () => { const flowRaw = JSON.stringify({ steps: [{ name: "美学纲领与交互范式", depends_on: [] }], }); const loaded = await loadWorkerSkillWithContext( "world-simulator", "design-flow", undefined, { selectedRecipeRef: "world-simulator", flowRaw, acceptedStepNames: ["美学纲领与交互范式"], filledArtifactTags: ["设计.美学纲领与交互范式"], }, ); expect(loaded.promptBody).toContain("【流程进度】"); expect(loaded.promptBody).toContain("已完成："); expect(loaded.promptBody).toContain("美学纲领与交互范式"); expect(loaded.promptBody).toContain("已验收"); expect(loaded.promptBody).toContain("这一面已覆盖"); expect(loaded.promptBody).toContain("要改则用户点该节点重进"); expect(loaded.promptBody).toContain("生成规则"); }); it("formatFlowProgressForAgent keeps seed steps as draft not new work", () => { const flow = parseCreationFlow(`{ "steps": [ { "name": "美学纲领与交互范式", "depends_on": [] } ] }`)!; const text = formatFlowProgressForAgent({ flow, acceptedStepIds: [], catalog: sampleCatalog, }); expect(text).toContain("草案已有、尚未验收"); expect(text).toContain("美学纲领与交互范式"); expect(text).toContain("保留原 id"); expect(text).toContain("目录〔可反复〕：生成规则、具体实例"); expect(text).toContain("尚未编入、仍可调用"); expect(text).toContain("实现机制"); const leftoverAt = text.indexOf("尚未编入、仍可调用"); expect(leftoverAt).toBeGreaterThan(-1); expect(text.slice(leftoverAt)).not.toContain("美学纲领与交互范式"); }); it("listCallableCatalogModules skips scheduled names and filled non-repeatable artifacts", () => { const flow = parseCreationFlow(`{ "steps": [ { "name": "美学纲领与交互范式", "depends_on": [] }, { "name": "生成规则", "role": "prototype", "depends_on": ["美学纲领与交互范式"] } ] }`)!; const leftover = listCallableCatalogModules({ flow, catalog: sampleCatalog, filledArtifactTags: ["设计.实现机制"], }); expect(leftover.map((m) => m.name)).toEqual([ "具体实例", "开场白与开场变量", ]); }); it("tells design-flow to insert nodes before an unaccepted closer", () => { const catalog = parseModuleCatalog(` modules: - name: 美学纲领与交互范式 declaration: 站位 artifact: 设计.美学纲领与交互范式 - name: 开场白与开场变量 declaration: 收口 artifact: 设计.开场白与开场变量 closer: true `)!; const flow = parseCreationFlow(`{ "status": "closed", "steps": [ { "name": "美学纲领与交互范式", "depends_on": [] }, { "name": "开场白与开场变量", "depends_on": ["美学纲领与交互范式"] } ] }`)!; const text = formatFlowProgressForAgent({ flow, acceptedStepIds: ["美学纲领与交互范式"], catalog, }); expect(text).toContain("〔收口〕"); expect(text).toContain("开场白与开场变量"); expect(text).toContain("插在收口之前"); expect(text).toContain("status 改回 open"); }); it("injects aesthetics-interaction module prompt into design-step", async () => { const flowRaw = JSON.stringify({ steps: [{ name: "美学纲领与交互范式", depends_on: [] }], }); const loaded = await loadWorkerSkillWithContext( "world-simulator", "design-step", undefined, { flowRaw, currentStepName: "美学纲领与交互范式", acceptedStepNames: [], }, ); expect(loaded.worker.outputTags).toContain("设计.美学纲领与交互范式"); expect(loaded.worker.outputTags).not.toContain("创作.当前步骤"); expect(loaded.worker.inputTags).toContain("创作.当前步骤"); expect(loaded.promptBody).toContain("美学纲领与交互范式"); expect(loaded.promptBody).toContain("体验契约"); expect(loaded.promptBody).toContain("程序开场"); expect(loaded.promptBody).toContain("【本步参数】"); expect(loaded.worker.inputTags).toContain("创作.能力开场白"); }); it("extracts ```opening default question from module prompt", async () => { const prompt = await loadModulePrompt( "dialogue/world-simulator", "aesthetics-interaction", ); expect(prompt).toBeTruthy(); const opening = extractModuleOpening(prompt!); expect(opening).toContain("反复获得什么体验"); expect(opening).toContain("站在什么位置"); expect(opening).not.toContain("nail清站位"); const { parseModulePromptSections, formatModulePromptForLlm, MODULE_SECTION_IDS, } = await import("../src/skills/creation-flow.js"); const sections = parseModulePromptSections(prompt!); for (const id of ["meta", "opening", "task", "output", "checklist"] as const) { expect(sections.blocks[id]?.length).toBeGreaterThan(0); } expect(MODULE_SECTION_IDS).toContain("opening"); const forLlm = formatModulePromptForLlm(prompt!); expect(forLlm).toContain("```task"); expect(forLlm).not.toContain("原型世界是什么"); expect( extractModuleOpening("## opening\n\n```opening\nhello world\n```\n"), ).toBe("hello world"); expect(parseModuleOpeningState('{"美学纲领与交互范式":"shown"}')).toEqual({ 美学纲领与交互范式: "shown", }); expect(isProgressPointerTag("创作.当前步骤")).toBe(true); expect(isProgressPointerTag("设计.美学纲领与交互范式")).toBe(false); expect(isProgressPointerTag("设计.创作流程")).toBe(false); const binding = await resolveDesignStepBinding({ skillPackRoot: "dialogue/world-simulator", flowRaw: JSON.stringify({ steps: [{ name: "美学纲领与交互范式", depends_on: [] }], }), currentStepName: "美学纲领与交互范式", }); expect(binding?.opening).toContain("反复获得什么体验"); expect(binding?.modulePrompt).toContain("```task"); expect(binding?.modulePrompt).not.toContain("最想反复感受到的是什么"); }); it("loads the migrated world-blueprint contract", async () => { const catalog = await loadModuleCatalog("dialogue/world-simulator"); const module = catalog?.modules.find((item) => item.id === "world-blueprint"); expect(module?.layer).toBe("final"); expect(module?.mount).toEqual(["world-simulator"]); const prompt = await loadModulePrompt( "dialogue/world-simulator", "world-blueprint", ); const { parseModulePromptSections } = await import( "../src/skills/creation-flow.js" ); const sections = parseModulePromptSections(prompt!); expect(sections.blocks.task).toContain("稳定反馈"); expect(sections.blocks.output).toContain('"核心运转"'); expect(sections.blocks.output).not.toContain('"自评"'); expect(sections.blocks.output).not.toContain('"追问"'); expect(sections.blocks.score).toContain("支撑度"); expect(sections.blocks.score).toContain("克制度"); expect(sections.blocks.score).not.toContain("0–10"); }); it("loads the migrated generation-rules contract", async () => { const catalog = await loadModuleCatalog("dialogue/world-simulator"); const module = catalog?.modules.find((item) => item.id === "generation-rules"); expect(module?.layer).toBe("final"); expect(module?.mount).toEqual(["world-simulator", "auditor"]); expect(module?.repeatable).toBe(true); const prompt = await loadModulePrompt( "dialogue/world-simulator", "generation-rules", ); const { parseModulePromptSections } = await import( "../src/skills/creation-flow.js" ); const sections = parseModulePromptSections(prompt!); expect(sections.blocks.meta).toContain("两份或以上"); expect(sections.blocks.task).toContain("填写工作流"); expect(sections.blocks.output).toContain('"字段"'); expect(sections.blocks.output).toContain('"填写工作流"'); expect(sections.blocks.output).toContain('"依赖关系"'); expect(sections.blocks.output).not.toContain('"rules"'); expect(sections.blocks.output).not.toContain('"自评"'); expect(sections.blocks.score).toContain("字段妥当"); expect(sections.blocks.score).toContain("池与提示"); expect(sections.blocks.score).toContain("填写工作流"); }); it("loads the migrated concrete-instances contract", async () => { const catalog = await loadModuleCatalog("dialogue/world-simulator"); const module = catalog?.modules.find( (item) => item.id === "concrete-instances", ); expect(module?.layer).toBe("final"); expect(module?.mount).toEqual(["world-simulator"]); expect(module?.repeatable).toBe(true); const prompt = await loadModulePrompt( "dialogue/world-simulator", "concrete-instances", ); const { parseModulePromptSections } = await import( "../src/skills/creation-flow.js" ); const sections = parseModulePromptSections(prompt!); expect(sections.blocks.meta).toContain("字段很少"); expect(sections.blocks.task).toContain("一份产物只含一条记录"); expect(sections.blocks.output).toContain('"名称"'); expect(sections.blocks.output).toContain('"记录"'); expect(sections.blocks.output).not.toContain('"自评"'); expect(sections.blocks.score).toContain("工作流符合度"); expect(sections.blocks.score).not.toContain("充实度"); }); it("loads the migrated narrative-guide contract", async () => { const catalog = await loadModuleCatalog("dialogue/world-simulator"); const module = catalog?.modules.find((item) => item.id === "narrative-guide"); expect(module?.layer).toBe("final"); expect(module?.mount).toEqual(["narrator", "world-simulator"]); expect(module?.libraries).toEqual(["style-packs"]); const prompt = await loadModulePrompt( "dialogue/world-simulator", "narrative-guide", ); const { parseModulePromptSections } = await import( "../src/skills/creation-flow.js" ); const sections = parseModulePromptSections(prompt!); expect(sections.blocks.task).toContain("read_library_entry"); expect(sections.blocks.task).toContain("风格推荐"); expect(sections.blocks.output).toContain('"选用文风"'); expect(sections.blocks.output).toContain('"写法要求"'); expect(sections.blocks.output).not.toContain('"示范"'); expect(sections.blocks.output).not.toContain('"自评"'); expect(sections.blocks.score).toContain("遣词可执行"); expect(sections.blocks.score).toContain("文风选用"); expect(sections.blocks.score).toContain("本局化"); }); it("loads the migrated story-progression contract", async () => { const catalog = await loadModuleCatalog("dialogue/world-simulator"); const module = catalog?.modules.find( (item) => item.id === "story-progression", ); expect(module?.layer).toBe("final"); expect(module?.mount).toEqual(["world-simulator", "narrator"]); expect(module?.libraries).toEqual(["preferences"]); const prompt = await loadModulePrompt( "dialogue/world-simulator", "story-progression", ); const { parseModulePromptSections } = await import( "../src/skills/creation-flow.js" ); const sections = parseModulePromptSections(prompt!); expect(sections.blocks.task).toContain("只选定一种"); expect(sections.blocks.task).toContain("read_library_entry"); expect(sections.blocks.output).toContain('"用户输入用法"'); expect(sections.blocks.output).toContain('"扩写要求"'); expect(sections.blocks.output).toContain('"续写要求"'); expect(sections.blocks.output).toContain('"单轮篇幅"'); expect(sections.blocks.output).toContain('"目标字数"'); expect(sections.blocks.output).toContain('"扩写占比"'); expect(sections.blocks.output).toContain('"续写占比"'); expect(sections.blocks.output).toContain('"OOC处理"'); expect(sections.blocks.output).not.toContain('"自评"'); expect(sections.blocks.score).toContain("唯一性与切分"); expect(sections.blocks.score).toContain("可执行性"); expect(sections.blocks.score).toContain("偏好本局化"); }); it("loads the migrated mechanism contract", async () => { const catalog = await loadModuleCatalog("dialogue/world-simulator"); const module = catalog?.modules.find((item) => item.id === "mechanism"); expect(module?.layer).toBe("final"); expect(module?.mount).toEqual(["world-simulator"]); const prompt = await loadModulePrompt( "dialogue/world-simulator", "mechanism", ); const { parseModulePromptSections } = await import( "../src/skills/creation-flow.js" ); const sections = parseModulePromptSections(prompt!); expect(sections.blocks.task).toContain("多条共同作用"); expect(sections.blocks.task).toContain("缺失后果"); expect(sections.blocks.output).toContain('"既成机制"'); expect(sections.blocks.output).toContain('"因果影响"'); expect(sections.blocks.output).toContain('"推演口径"'); expect(sections.blocks.output).toContain('"共同作用"'); expect(sections.blocks.output).not.toContain('"缺失后果"'); expect(sections.blocks.output).not.toContain('"自评"'); expect(sections.blocks.score).toContain("骨架必要度"); expect(sections.blocks.score).toContain("因果清晰度"); expect(sections.blocks.score).toContain("推演开放度"); expect(sections.blocks.examples).toContain("灵气复苏"); expect(sections.blocks.examples).toContain("全民直播求生"); }); it("loads the migrated topology contract", async () => { const catalog = await loadModuleCatalog("dialogue/world-simulator"); const module = catalog?.modules.find((item) => item.id === "topology"); expect(module?.layer).toBe("final"); expect(module?.mount).toEqual(["world-simulator", "auditor"]); expect(module?.repeatable).toBe(true); const prompt = await loadModulePrompt( "dialogue/world-simulator", "topology", ); const { parseModulePromptSections } = await import( "../src/skills/creation-flow.js" ); const sections = parseModulePromptSections(prompt!); expect(sections.blocks.task).toContain("一张图"); expect(sections.blocks.task).toContain("static"); expect(sections.blocks.task).toContain("record"); expect(sections.blocks.task).toContain("expand"); expect(sections.blocks.output).toContain('"节点字段"'); expect(sections.blocks.output).toContain('"连接字段"'); expect(sections.blocks.output).toContain('"初始图"'); expect(sections.blocks.output).toContain('"维护规则"'); expect(sections.blocks.output).not.toContain('"自评"'); expect(sections.blocks.output).not.toContain("SVG"); expect(sections.blocks.score).toContain("对象适配"); expect(sections.blocks.score).toContain("字段合同"); expect(sections.blocks.score).toContain("初始图有效性"); expect(sections.blocks.score).toContain("维护可执行性"); expect(sections.blocks.score).toContain("长期一致性"); }); it("loads the migrated variable-design contract", async () => { const catalog = await loadModuleCatalog("dialogue/world-simulator"); const module = catalog?.modules.find((item) => item.id === "variable-design"); expect(module?.layer).toBe("final"); expect(module?.mount).toEqual(["world-simulator", "auditor"]); const prompt = await loadModulePrompt( "dialogue/world-simulator", "variable-design", ); const { parseModulePromptSections } = await import( "../src/skills/creation-flow.js" ); const sections = parseModulePromptSections(prompt!); expect(sections.blocks.task).toContain("deterministic"); expect(sections.blocks.task).toContain("narrative_inference"); expect(sections.blocks.task).toContain("inline_tool"); expect(sections.blocks.task).toContain("auditor_bundle"); expect(sections.blocks.output).toContain('"允许写入者"'); expect(sections.blocks.output).toContain('"更新规则"'); expect(sections.blocks.output).toContain('"派生映射"'); expect(sections.blocks.output).toContain('"触发规则"'); expect(sections.blocks.output).toContain('"维护复杂度"'); expect(sections.blocks.output).not.toContain('"自评"'); expect(sections.blocks.output).not.toContain("maintain.v1"); expect(sections.blocks.output).not.toContain("隐藏段"); expect(sections.blocks.score).toContain("真值必要性"); expect(sections.blocks.score).toContain("字段妥当性"); expect(sections.blocks.score).toContain("更新可执行性"); expect(sections.blocks.score).toContain("权限与公开性"); expect(sections.blocks.score).toContain("映射与触发一致性"); }); it("loads the migrated status-bar contract", async () => { const catalog = await loadModuleCatalog("dialogue/world-simulator"); const module = catalog?.modules.find((item) => item.id === "status-bar"); expect(module?.layer).toBe("final"); expect(module?.mount).toEqual(["world-simulator", "narrator"]); const prompt = await loadModulePrompt( "dialogue/world-simulator", "status-bar", ); const { parseModulePromptSections } = await import( "../src/skills/creation-flow.js" ); const sections = parseModulePromptSections(prompt!); expect(sections.blocks.task).toContain("语义区域"); expect(sections.blocks.task).toContain("inline"); expect(sections.blocks.output).toContain('"语义区域"'); expect(sections.blocks.output).toContain("program_projection"); expect(sections.blocks.output).toContain("maintenance_channel"); expect(sections.blocks.output).toContain("state_ops"); expect(sections.blocks.output).not.toContain('"启用"'); expect(sections.blocks.output).not.toContain("1000～2000"); expect(sections.blocks.output).not.toContain('"自评"'); expect(sections.blocks.score).toContain("区域必要性"); expect(sections.blocks.score).toContain("来源一致性"); expect(sections.blocks.score).toContain("内容可执行性"); expect(sections.blocks.score).toContain("信息负担"); expect(sections.blocks.score).toContain("职责边界"); }); it("loads the migrated random-range contract", async () => { const catalog = await loadModuleCatalog("dialogue/world-simulator"); const module = catalog?.modules.find((item) => item.id === "random-range"); expect(module?.layer).toBe("final"); expect(module?.mount).toEqual(["world-simulator"]); const prompt = await loadModulePrompt( "dialogue/world-simulator", "random-range", ); const { parseModulePromptSections } = await import( "../src/skills/creation-flow.js" ); const sections = parseModulePromptSections(prompt!); expect(sections.blocks.task).toContain("名称.随机数"); expect(sections.blocks.task).toContain("只剩 1 个"); expect(sections.blocks.output).toContain("敏捷.随机数"); expect(sections.blocks.output).not.toContain("票 id"); expect(sections.blocks.output).not.toContain('"自评"'); expect(sections.blocks.score).toContain("覆盖度"); expect(sections.blocks.score).toContain("克制"); }); it("loads the migrated reply-format contract", async () => { const catalog = await loadModuleCatalog("dialogue/world-simulator"); const module = catalog?.modules.find((item) => item.id === "reply-format"); expect(module?.layer).toBe("final"); expect(module?.mount).toEqual(["world-simulator", "narrator"]); const prompt = await loadModulePrompt( "dialogue/world-simulator", "reply-format", ); const { parseModulePromptSections } = await import( "../src/skills/creation-flow.js" ); const sections = parseModulePromptSections(prompt!); expect(sections.blocks.task).toContain("普通楼层"); expect(sections.blocks.task).toContain("present.onData"); expect(sections.blocks.output).toContain('"数据契约"'); expect(sections.blocks.output).toContain('"区域落点"'); expect(sections.blocks.output).toContain('"frontend"'); expect(sections.blocks.output).toContain('"html"'); expect(sections.blocks.output).toContain('"css"'); expect(sections.blocks.output).toContain('"js"'); expect(sections.blocks.output).toContain('"示例灌数"'); expect(sections.blocks.output).not.toContain('"自评"'); expect(sections.blocks.score).toContain("区域落实"); expect(sections.blocks.score).toContain("权威绑定"); expect(sections.blocks.score).toContain("实现完整"); expect(sections.blocks.score).toContain("本局化"); }); it("loads the migrated opening-setup contract", async () => { const catalog = await loadModuleCatalog("dialogue/world-simulator"); const module = catalog?.modules.find((item) => item.id === "opening-setup"); expect(module?.layer).toBe("final"); expect(module?.mount).toEqual(["world-simulator", "narrator"]); expect(module?.closer).toBe(true); expect(module?.repeatable).toBe(true); const prompt = await loadModulePrompt( "dialogue/world-simulator", "opening-setup", ); const { parseModulePromptSections } = await import( "../src/skills/creation-flow.js" ); const sections = parseModulePromptSections(prompt!); expect(sections.blocks.task).toContain("默认只生成 1 条"); expect(sections.blocks.task).toContain("@玩家"); expect(sections.blocks.task).toContain("随机"); expect(module?.artifact).toBe("设计.开场白"); expect(sections.blocks.task).toContain("设计.开场白#opening-cycle2"); expect(sections.blocks.task).not.toContain("写入 `设计.开场白与开场变量`"); expect(sections.blocks.output).toContain("设计.开场白#场景短码"); expect(sections.blocks.output).toContain('"开场变量"'); expect(sections.blocks.output).not.toContain('"开场白候选"'); expect(sections.blocks.output).not.toContain('"开场白全文"'); expect(sections.blocks.output).toContain("present.v1"); expect(sections.blocks.output).not.toContain('"自评"'); expect(sections.blocks.score).toContain("开场必要"); expect(sections.blocks.score).toContain("前端符合"); expect(sections.blocks.score).toContain("状态自洽"); expect(sections.blocks.score).toContain("角色占位"); expect(sections.blocks.score).toContain("收口可切换"); }); it("loads the three zero-layer presentation contracts", async () => { const catalog = await loadModuleCatalog("dialogue/world-simulator"); const ids = [ "zero-layer-status", "zero-layer-reply-format", "zero-layer-opening-setup", ]; for (const id of ids) { const module = catalog?.modules.find((item) => item.id === id); expect(module?.layer).toBe("final"); expect(module?.mount).toEqual(["world-simulator", "narrator"]); const prompt = await loadModulePrompt("dialogue/world-simulator", id); const { parseModulePromptSections } = await import( "../src/skills/creation-flow.js" ); const sections = parseModulePromptSections(prompt!); expect(sections.blocks.task).toBeTruthy(); expect(sections.blocks.output).not.toContain('"自评"'); expect(sections.blocks.score).toBeTruthy(); } expect( catalog?.modules.find((item) => item.id === "zero-layer-opening-setup") ?.closer, ).toBe(true); expect( catalog?.modules.find((item) => item.id === "zero-layer-opening-setup") ?.repeatable, ).toBe(true); const formatPrompt = await loadModulePrompt( "dialogue/world-simulator", "zero-layer-reply-format", ); expect(formatPrompt).toContain("zero-layer.update.v1"); expect(formatPrompt).toContain("slot_updates"); expect(formatPrompt).toContain("base_revision"); const openingPrompt = await loadModulePrompt( "dialogue/world-simulator", "zero-layer-opening-setup", ); expect(openingPrompt).toContain("zero-layer.card.v1"); expect(openingPrompt).toContain("@玩家"); expect(openingPrompt).toContain("不输出任何 `名称.随机数`"); }); it("parses and validates step params from catalog", async () => { const flow = parseCreationFlow(`{ "status": "open", "steps": [ { "id": "生成规则·怪物", "name": "生成规则", "params": { "target": "怪物", "lifecycle_intent": "runtime_only" }, "depends_on": [] } ] }`)!; expect(flow.steps[0]?.params).toEqual({ target: "怪物", lifecycle_intent: "runtime_only", }); const view = formatCreationFlowForUser(flow); expect(view.steps[0]?.params?.target).toBe("怪物"); const catalog = await loadModuleCatalog("dialogue/world-simulator"); const rules = catalog?.modules.find((m) => m.name === "生成规则"); expect(rules?.kind).toBe("prior-artifact"); expect(rules?.params?.some((p) => p.key === "target")).toBe(true); expect(validateCreationFlow(flow, catalog).ok).toBe(true); const missing = parseCreationFlow(`{ "steps": [{ "name": "生成规则", "depends_on": [] }] }`)!; // 先验产物：编排期允许空壳，确认开干也不拦 expect(validateCreationFlow(missing, catalog).ok).toBe(true); const stepReady = validateStepReadyToRun(missing.steps[0]!, catalog); expect(stepReady.ok).toBe(true); const missingView = formatCreationFlowForUser(missing, catalog); expect(missingView.steps[0]?.kind).toBe("prior-artifact"); expect(missingView.steps[0]?.paramsMissing).toBeUndefined(); const block = formatModuleCatalogForAgent(catalog!); expect(block).toContain("role=prototype"); expect(block).toContain("target"); }); it("injects step params into design-step prompt", async () => { const flowRaw = JSON.stringify({ steps: [ { id: "生成规则·怪物", name: "生成规则", params: { target: "怪物", rule_id: "monsters" }, depends_on: [], }, ], }); const loaded = await loadWorkerSkillWithContext( "world-simulator", "design-step", undefined, { flowRaw, currentStepName: "生成规则·怪物", acceptedStepNames: [], }, ); expect(loaded.promptBody).toContain("【本步对象】"); expect(loaded.promptBody).toContain("target: 怪物"); expect(loaded.promptBody).toContain("rule_id: monsters"); expect(loaded.worker.outputTags).toEqual(["设计.生成规则#monsters"]); }); it("lands each rule, instance, and opening on its own tag", () => { const catalog = parseModuleCatalog(` modules: - id: generation-rules name: 生成规则 declaration: 一条规则一份产物 artifact: 设计.生成规则 repeatable: true - id: concrete-instances name: 具体实例 declaration: 一条记录一份产物 artifact: 设计.具体实例 repeatable: true - id: opening-setup name: 开场白与开场变量 declaration: 一条开场一份产物 artifact: 设计.开场白与开场变量 repeatable: true closer: true - id: aesthetics-interaction name: 美学纲领与交互范式 declaration: 一次写完 artifact: 设计.美学纲领与交互范式 `)!; const rule = catalog.modules.find((m) => m.id === "generation-rules")!; const row = catalog.modules.find((m) => m.id === "concrete-instances")!; const opening = catalog.modules.find((m) => m.id === "opening-setup")!; const once = catalog.modules.find((m) => m.id === "aesthetics-interaction")!; expect( repeatableInstanceProductTag({ module: rule, step: { id: "生成规则·怪物", role: "instance", params: { rule_id: "女租客" } }, }), ).toBe("设计.生成规则#女租客"); expect( repeatableInstanceProductTag({ module: row, step: { id: "具体实例#1", role: "instance", params: { batch_goal: "雷樱" } }, }), ).toBe("设计.具体实例#1"); expect( repeatableInstanceProductTag({ module: row, step: { id: "具体实例·雷樱", role: "instance", params: { batch_goal: "雷樱" } }, }), ).toBe("设计.具体实例#雷樱"); expect( repeatableInstanceProductTag({ module: opening, step: { id: "开场白与开场变量#dorm", role: "instance" }, }), ).toBe("设计.开场白#dorm"); expect( repeatableInstanceProductTag({ module: once, step: { id: "美学纲领与交互范式", role: "instance" }, }), ).toBeNull(); }); it("injects empty prior-artifact plan and still lets the step run", async () => { const catalog = parseModuleCatalog(` modules: - name: 生成规则 declaration: 可执行规则 artifact: 设计.生成规则 kind: prior-artifact params: - key: target label: 生成对象 required: true `)!; const empty = parseCreationFlow(`{ "steps": [{ "name": "生成规则", "depends_on": [] }] }`)!; expect(catalog.modules[0]?.kind).toBe("prior-artifact"); expect(validateStepReadyToRun(empty.steps[0]!, catalog).ok).toBe(true); const loaded = await loadWorkerSkillWithContext( "world-simulator", "design-step", undefined, { flowRaw: JSON.stringify({ steps: [ { id: "生成规则#1", name: "生成规则", role: "instance", from: "生成规则", depends_on: [], }, ], }), currentStepName: "生成规则#1", acceptedStepNames: [], }, ); expect(loaded.promptBody).toContain("【本步对象】"); expect(loaded.promptBody).toContain("尚未钉本步具体写什么"); }); it("nextPendingStep respects deps and accepted by id", () => { const flow = parseCreationFlow(`{ "status": "open", "steps": [ { "name": "美学纲领与交互范式", "depends_on": [] }, { "name": "生成规则", "depends_on": ["美学纲领与交互范式"] }, { "id": "生成规则#2", "name": "生成规则", "depends_on": ["生成规则"] } ] }`)!; expect(nextPendingStep(flow, [])?.id).toBe("美学纲领与交互范式"); expect(nextPendingStep(flow, ["美学纲领与交互范式"])?.id).toBe("生成规则"); expect(nextPendingStep(flow, ["美学纲领与交互范式", "生成规则"])?.id).toBe( "生成规则#2", ); expect( nextPendingStep(flow, ["美学纲领与交互范式", "生成规则", "生成规则#2"]), ).toBeNull(); }); it("pickRecordedStepId ignores LLM junk on 创作.当前步骤", () => { const flow = parseCreationFlow(`{ "status": "open", "steps": [ { "name": "美学纲领与交互范式", "depends_on": [] }, { "name": "生成规则", "depends_on": ["美学纲领与交互范式"] } ] }`)!; expect( pickRecordedStepId({ flow, alreadyAccepted: [], pinnedUnitId: "美学纲领与交互范式", writtenCurrentStep: JSON.stringify({ schema: "context-fragment.v1", 正文: { 交互范式: {}, 美学纲领: {} }, }), }), ).toBe("美学纲领与交互范式"); expect( pickRecordedStepId({ flow, alreadyAccepted: [], pinnedUnitId: "flow", writtenCurrentStep: "交互范式", }), ).toBe("美学纲领与交互范式"); expect( pickRecordedStepId({ flow, alreadyAccepted: ["美学纲领与交互范式"], pinnedUnitId: "", writtenCurrentStep: "", }), ).toBe("生成规则"); }); it("open flow needs expansion after listed steps accepted", () => { const flow = parseCreationFlow(`{ "status": "open", "steps": [{ "name": "美学纲领与交互范式", "depends_on": [] }] }`)!; expect(isCreationFlowComplete(flow, ["美学纲领与交互范式"])).toBe(false); expect(needsFlowExpansion(flow, ["美学纲领与交互范式"])).toBe(true); const closed = parseCreationFlow(`{ "status": "closed", "steps": [{ "name": "美学纲领与交互范式", "depends_on": [] }] }`)!; expect(isCreationFlowComplete(closed, ["美学纲领与交互范式"])).toBe(true); expect(needsFlowExpansion(closed, ["美学纲领与交互范式"])).toBe(false); const legacy = parseCreationFlow(`{ "steps": [{ "name": "美学纲领与交互范式", "depends_on": [] }] }`)!; expect(isCreationFlowComplete(legacy, ["美学纲领与交互范式"])).toBe(true); }); it("parses legacy revise steps then strips them from the user graph", () => { const flow = parseCreationFlow(`{ "status": "open", "steps": [ { "name": "实现机制", "depends_on": [] }, { "name": "实现机制", "mode": "回头修改", "depends_on": ["实现机制"] } ] }`)!; expect(flow.steps[1]).toMatchObject({ id: "实现机制·改", name: "实现机制", mode: "revise", revises: "实现机制", }); expect(validateCreationFlow(flow, sampleCatalog).ok).toBe(true); const stripped = stripReviseSteps(flow); expect(stripped.steps.map((s) => s.id)).toEqual(["实现机制"]); const view = formatCreationFlowForUser(flow, sampleCatalog, ["实现机制"]); expect(view.steps).toHaveLength(1); expect(view.steps[0]?.id).toBe("实现机制"); expect(view.steps[0]?.runState).toBe("done"); expect(view.steps[0]?.mode).toBeUndefined(); }); it("stripReviseSteps remaps dependents back to the origin step", () => { const flow = parseCreationFlow(`{ "steps": [ { "id": "美学纲领与交互范式", "name": "美学纲领与交互范式", "depends_on": [] }, { "id": "美学纲领与交互范式·改", "name": "美学纲领与交互范式", "mode": "revise", "revises": "美学纲领与交互范式", "depends_on": ["美学纲领与交互范式"] }, { "id": "正文组成", "name": "实现机制", "depends_on": ["美学纲领与交互范式·改"] } ] }`)!; const stripped = stripReviseSteps(flow); expect(stripped.steps.map((s) => s.id)).toEqual([ "美学纲领与交互范式", "正文组成", ]); expect(stripped.steps[1]?.depends_on).toEqual(["美学纲领与交互范式"]); }); it("still rejects two fresh copies of a non-repeatable skill", () => { const flow = parseCreationFlow(`{ "steps": [ { "name": "实现机制", "depends_on": [] }, { "id": "实现机制#2", "name": "实现机制", "depends_on": ["实现机制"] } ] }`)!; const result = validateCreationFlow(flow, sampleCatalog); expect(result.ok).toBe(false); expect(result.errors.some((e) => e.includes("repeatable"))).toBe(true); }); it("treats a second generation-rules step as fresh, not revise", () => { const flow = parseCreationFlow(`{ "steps": [ { "id": "生成规则·怪物", "name": "生成规则", "params": { "target": "怪物" }, "depends_on": [] }, { "id": "生成规则·NPC", "name": "生成规则", "params": { "target": "NPC" }, "depends_on": ["生成规则·怪物"] } ] }`)!; expect(flow.steps[1]?.mode).toBeUndefined(); expect(validateCreationFlow(flow, sampleCatalog).ok).toBe(true); }); it("revise of generation-rules inherits params from the origin step", () => { const flow = parseCreationFlow(`{ "steps": [ { "id": "生成规则·怪物", "name": "生成规则", "params": { "target": "怪物", "rule_id": "monsters" }, "depends_on": [] }, { "id": "生成规则·怪物·改", "name": "生成规则", "mode": "revise", "revises": "生成规则·怪物", "depends_on": ["生成规则·怪物"] } ] }`)!; expect(flow.steps[1]?.params).toEqual({ target: "怪物", rule_id: "monsters", }); expect(validateCreationFlow(flow, sampleCatalog).ok).toBe(true); }); it("nextPendingStep ignores orchestrated revise steps", () => { const flow = parseCreationFlow(`{ "status": "open", "steps": [ { "name": "美学纲领与交互范式", "depends_on": [] }, { "name": "生成规则", "depends_on": ["美学纲领与交互范式"] }, { "name": "美学纲领与交互范式", "mode": "revise", "revises": "美学纲领与交互范式", "depends_on": ["美学纲领与交互范式"] } ] }`)!; expect(nextPendingStep(flow, ["美学纲领与交互范式"])?.mode).toBeUndefined(); expect(nextPendingStep(flow, ["美学纲领与交互范式"])?.id).toBe("生成规则"); expect( listReadySteps(flow, ["美学纲领与交互范式"]).map((s) => s.id), ).toEqual(["生成规则"]); }); it("inherits existing artifact when reentering an accepted step", async () => { const flowRaw = JSON.stringify({ status: "open", steps: [ { id: "美学纲领与交互范式", name: "美学纲领与交互范式", depends_on: [] }, ], }); const binding = await resolveDesignStepBinding({ skillPackRoot: "dialogue/world-simulator", flowRaw, currentStepName: "美学纲领与交互范式", acceptedStepNames: ["美学纲领与交互范式"], inheritExisting: true, }); expect(binding?.opening).toBeNull(); expect(binding?.inheritTag).toBe("设计.美学纲领与交互范式"); const loaded = await loadWorkerSkillWithContext( "world-simulator", "design-step", undefined, { flowRaw, currentStepName: "美学纲领与交互范式", acceptedStepNames: ["美学纲领与交互范式"], inheritExisting: true, }, ); expect(loaded.promptBody).toContain("【回头修改】"); expect(loaded.promptBody).not.toContain("程序开场"); expect(loaded.worker.name).toContain("回头修改"); expect(loaded.worker.inputTags).toContain("设计.美学纲领与交互范式"); }); it("layers follow longest dependency path", () => { const flow = parseCreationFlow(`{ "steps": [ { "name": "美学纲领与交互范式", "depends_on": [] }, { "name": "生成规则", "depends_on": ["美学纲领与交互范式"] }, { "name": "具体实例", "depends_on": ["生成规则"] }, { "name": "开场白与开场变量", "depends_on": ["美学纲领与交互范式", "具体实例"] } ] }`)!; const layers = computeStepLayers(flow); expect(layers.get("美学纲领与交互范式")).toBe(0); expect(layers.get("生成规则")).toBe(1); expect(layers.get("具体实例")).toBe(2); expect(layers.get("开场白与开场变量")).toBe(3); }); it("listReadySteps returns every unblocked pending step", () => { const flow = parseCreationFlow(`{ "steps": [ { "name": "美学纲领与交互范式", "depends_on": [] }, { "name": "生成规则", "depends_on": ["美学纲领与交互范式"] }, { "id": "实现机制", "name": "实现机制", "depends_on": ["美学纲领与交互范式"] } ] }`)!; expect(listReadySteps(flow, []).map((s) => s.id)).toEqual([ "美学纲领与交互范式", ]); expect( listReadySteps(flow, ["美学纲领与交互范式"]).map((s) => s.id), ).toEqual(["生成规则", "实现机制"]); }); it("spawns instance from prototype before closer and hangs instance on closer deps", () => { const flow = parseCreationFlow(`{ "status": "open", "steps": [ { "name": "美学纲领与交互范式", "depends_on": [] }, { "name": "开场白与开场变量", "depends_on": ["美学纲领与交互范式"] } ] }`)!; expect( hasSelectableCreationWork(flow, sampleCatalog, ["美学纲领与交互范式"]), ).toBe(true); const spawned = spawnRepeatableCreationStep({ flow, catalog: sampleCatalog, moduleName: "生成规则", acceptedStepIds: ["美学纲领与交互范式"], }); expect("error" in spawned).toBe(false); if ("error" in spawned) return; expect(spawned.step.id).toBe("生成规则#1"); expect(spawned.step.role).toBe("instance"); expect(spawned.step.depends_on).toEqual(["美学纲领与交互范式"]); expect(spawned.flow.steps.map((s) => s.id)).toEqual([ "美学纲领与交互范式", "生成规则", "生成规则#1", "开场白与开场变量", ]); expect( spawned.flow.steps.find((s) => s.name === "开场白与开场变量")?.depends_on, ).toEqual(["美学纲领与交互范式", "生成规则#1"]); const second = spawnRepeatableCreationStep({ flow: spawned.flow, catalog: sampleCatalog, moduleName: "生成规则", acceptedStepIds: ["美学纲领与交互范式"], }); expect("error" in second).toBe(false); if ("error" in second) return; expect(second.step.id).toBe("生成规则#2"); }); it("spawns an opening instance from its own prototype without depending on itself", () => { const catalog = parseModuleCatalog(` modules: - name: 开场白与开场变量 declaration: 可增殖收口 artifact: 设计.开场白与开场变量 closer: true repeatable: true `)!; const flow = parseCreationFlow(`{ "status": "open", "steps": [ { "id": "开场白与开场变量", "name": "开场白与开场变量", "role": "prototype", "depends_on": [] } ] }`)!; const spawned = spawnInstanceFromPrototype({ flow, catalog, prototypeId: "开场白与开场变量", acceptedStepIds: [], }); expect("error" in spawned).toBe(false); if ("error" in spawned) return; expect(spawned.step.role).toBe("instance"); expect(spawned.step.from).toBe("开场白与开场变量"); expect(spawned.step.depends_on).toEqual([]); const proto = spawned.flow.steps.find((s) => s.role === "prototype"); expect(proto?.depends_on).toEqual([]); expect(spawned.flow.steps.map((s) => s.id)).toEqual([ "开场白与开场变量", "开场白与开场变量#1", ]); }); it("removeUnstartedInstance drops empty spawn and closer dep", () => { const flow = parseCreationFlow(`{ "status": "open", "steps": [ { "name": "美学纲领与交互范式", "depends_on": [] }, { "id": "生成规则", "name": "生成规则", "role": "prototype", "depends_on": ["美学纲领与交互范式"] }, { "id": "生成规则#1", "name": "生成规则", "role": "instance", "from": "生成规则", "depends_on": ["美学纲领与交互范式"] }, { "name": "开场白与开场变量", "depends_on": ["美学纲领与交互范式", "生成规则#1"] } ] }`)!; const next = removeUnstartedInstance(flow, "生成规则#1", []); expect(next.steps.map((s) => s.id)).toEqual([ "美学纲领与交互范式", "生成规则", "开场白与开场变量", ]); expect( next.steps.find((s) => s.name === "开场白与开场变量")?.depends_on, ).toEqual(["美学纲领与交互范式"]); const kept = removeUnstartedInstance(next, "美学纲领与交互范式", []); expect(kept.steps.map((s) => s.id)).toEqual(next.steps.map((s) => s.id)); const accepted = removeUnstartedInstance(flow, "生成规则#1", ["生成规则#1"]); expect(accepted.steps.some((s) => s.id === "生成规则#1")).toBe(true); }); it("removeRepeatableInstance drops accepted spawn and closer dep", () => { const flow = parseCreationFlow(`{ "status": "open", "steps": [ { "name": "美学纲领与交互范式", "depends_on": [] }, { "id": "生成规则", "name": "生成规则", "role": "prototype", "depends_on": ["美学纲领与交互范式"] }, { "id": "生成规则#1", "name": "生成规则", "role": "instance", "from": "生成规则", "depends_on": ["美学纲领与交互范式"], "params": { "rule_id": "core-female-roles" } }, { "name": "开场白与开场变量", "depends_on": ["美学纲领与交互范式", "生成规则#1"] } ] }`)!; const dropped = removeRepeatableInstance({ flow, stepId: "生成规则#1", catalog: sampleCatalog, }); expect("error" in dropped).toBe(false); if ("error" in dropped) return; expect(dropped.flow.steps.map((s) => s.id)).toEqual([ "美学纲领与交互范式", "生成规则", "开场白与开场变量", ]); expect( dropped.flow.steps.find((s) => s.name === "开场白与开场变量")?.depends_on, ).toEqual(["美学纲领与交互范式"]); }); it("removeRepeatableInstance blocks when another instance depends on it", () => { const flow = parseCreationFlow(`{ "steps": [ { "name": "美学纲领与交互范式", "depends_on": [] }, { "id": "生成规则", "name": "生成规则", "role": "prototype", "depends_on": ["美学纲领与交互范式"] }, { "id": "生成规则#1", "name": "生成规则", "role": "instance", "from": "生成规则", "depends_on": ["美学纲领与交互范式"], "params": { "target": "4位核心女性", "rule_id": "core-female-roles" } }, { "id": "具体实例", "name": "具体实例", "role": "prototype", "depends_on": ["生成规则"] }, { "id": "具体实例#1", "name": "具体实例", "role": "instance", "from": "具体实例", "depends_on": ["生成规则#1"] } ] }`)!; const blocked = removeRepeatableInstance({ flow, stepId: "生成规则#1", catalog: sampleCatalog, }); expect(blocked).toMatchObject({ error: expect.stringContaining("具体实例") }); const ok = removeRepeatableInstance({ flow, stepId: "具体实例#1", catalog: sampleCatalog, }); expect("error" in ok).toBe(false); }); it("pruneRepeatableArtifactContent strips the deleted rule_id", () => { const raw = JSON.stringify({ schema: "context-fragment.v1", 技能: "生成规则", brief: "两条规则", 正文: { rules: [ { rule_id: "core-female-roles", 对象: "女臣" }, { rule_id: "zombies", 对象: "丧尸" }, ], }, }); const step = { id: "生成规则#1", name: "生成规则", role: "instance" as const, depends_on: [], params: { rule_id: "core-female-roles" }, }; const pruned = JSON.parse( pruneRepeatableArtifactContent({ raw, step, remainingSameModule: 1, }), ); expect(pruned.正文.rules.map((r) => r.rule_id)).toEqual(["zombies"]); expect( pruneRepeatableArtifactContent({ raw, step, remainingSameModule: 0, }), ).toBe(""); }); it("blocks 具体实例 spawn until a 生成规则 instance is accepted", () => { const flow = parseCreationFlow(`{ "steps": [ { "name": "美学纲领与交互范式", "depends_on": [] }, { "id": "生成规则", "name": "生成规则", "role": "prototype", "depends_on": ["美学纲领与交互范式"] } ] }`)!; const blocked = spawnRepeatableCreationStep({ flow, catalog: sampleCatalog, moduleName: "具体实例", acceptedStepIds: ["美学纲领与交互范式"], }); expect(blocked).toMatchObject({ error: "先完成一条生成规则" }); const ruleSpawn = spawnInstanceFromPrototype({ flow, catalog: sampleCatalog, prototypeId: "生成规则", acceptedStepIds: ["美学纲领与交互范式"], }); expect("error" in ruleSpawn).toBe(false); if ("error" in ruleSpawn) return; const withRule = ruleSpawn.flow; const ok = spawnRepeatableCreationStep({ flow: withRule, catalog: sampleCatalog, moduleName: "具体实例", acceptedStepIds: ["美学纲领与交互范式", "生成规则#1"], }); expect("error" in ok).toBe(false); if ("error" in ok) return; expect(ok.step.depends_on).toEqual(["生成规则#1"]); }); it("detects accepted closer step", () => { const flow = parseCreationFlow( JSON.stringify({ steps: [ { id: "开场白与开场变量", name: "开场白与开场变量", depends_on: [], }, ], }), ); expect(hasAcceptedCloserStep(flow, [])).toBe(false); expect(hasAcceptedCloserStep(flow, ["开场白与开场变量"])).toBe(true); expect(hasAcceptedCloserStep(null, ["开场白与开场变量"])).toBe(true); }); });