范式退役:活动只剩一种、只跑 Loop;审批活动可管;活动库重做

用户定的两件,一并落地。

**一、活动不再分 flow 和 loop —— 彻底退役 flow**
  · `flow-engine` 模块整个删除(runner 379 行 + step-sequence 184 行 + 测试);
  · `paradigm` 从清单身份、`activity_package`/`task` 两张表、任务卡与活动库一并退场;
    `businessModel` 不再是判别联合 —— 只有案例模型(CMMN + 说明书 + DMN)一形;
  · task 的引擎分派从「按 paradigm 取两个之一」收成**唯一的引擎**;
  · `activities/` 四个 flow 活动(A1 受理 / A4 定价 / A6 议价 / A7 归档)各写了一份
    案例模型:阶段照原来的步分,触达世界的项一律 manualActivationRule,
    能算的交 DMN(A1 的三分类 P-03、A4 的 P-01/P-02)不交 Agent;
  · 六个占位槽位的骨架从「机器步落台账 + 一张验收单」改成案例骨架,包版本 0.8.0 → 0.9.0。

**代价写在明处,不假装没有**:`turn-runner` 每一拍都要 `agent.decide` ——
环境里没有模型 key,案例活动一步也走不动。三套端到端(统一报价 / 新建流程包 / 测试台
Trace)整套跳过,文件头写明恢复条件:①有可用模型 ②走法改写成按 Enabled 集推进。
**不许把断言改松让它变绿** —— 绿得不诚实比红着更坏。debt.md 已记。

**二、审批活动可管**(新能力)
  · `sys.approval_template`:审批点**可复用的那一半** —— 审批人看哪几项、按什么名字看、
    怎么催、说什么话。谁来审不在里面(与活动点同口径,运营时轮值);驳回回哪个节点
    也不在里面(那是每张图自己的事,留在节点上);
  · 三条路由 + 引用反查:还被审批点引着就不许删(409),删了那些节点会**静默**退回旧行为;
  · 运行时 `basisOf`:引了模板就按模板筛与改名,没引即旧行为(载荷全摊开)。
    模板改了只影响新发出的审批单 —— 在途单的依据在发出那一刻已定形。

**三、活动库重做**:一区两格 —— 「活动(装进来的)」与「审批活动(配出来的)」,
都用流程卡那套两段式卡片(头 + 四格数据板),幽灵卡当入口(装入活动 / 新建审批活动);
「标准/案例」那一维随范式一起撤,业务分类成了唯一的一维,以行内小签呈现。

迁移 0020:两张表 drop paradigm、建 approval_template。已在开发库跑过并重播种。
实测(丁子乔账号):建「定价审批」模板 → 流程包 A5 属性里选得到 → 引用反查计数正确。
四闸绿(api:check 随本提交)。

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KeDBx2PHLavbURXB8LJJ7m

apps/api/src/app/wiring/engines.ts

@@ -21,7 +21,6 @@ import type { ActivityRegistryService } from '@modules/activity-registry';
 import type { SkillEngineService } from '@modules/skill-engine';
 import type { ReleaseService } from '@modules/release';
 
-import { createFlowRunner, createFlowStateStore } from '@modules/flow-engine';
 import { createLoopStateStore, createTurnRunner } from '@modules/loop-engine';
 import { createSkillEngineService } from '@modules/skill-engine';
 import { createTaskService, createTaskStore } from '@modules/task';
@@ -379,48 +378,6 @@ export function wireEngines(deps: EngineWiringDeps): EngineWiring {
   });
   void skills;
 
-  /* ── flow-engine ──────────────────────────────────────────────── */
-  const flow = createFlowRunner({
-    state: createFlowStateStore(db),
-    evaluate: sfeel.condition,
-    data: taskData,
-    tools: { ...toolGateway, invoke: (i) => toolGateway.invoke(i) },
-    schemas: deps.schemas,
-    views: viewGateway,
-    llm: {
-      async generate(input) {
-        // LLM 在 flow 里只以「被调用的工具」出现,不是调度者
-        try {
-          const result = await deps.modelGateway.generate({
-            model: input.model,
-            prompt: input.prompt,
-            outputSchema: input.outputSchema,
-            taskId: input.taskId,
-            stepNo: input.stepNo,
-            label: 'flow-step',
-          });
-          // token 计入任务预算 —— 单位成本与预算熔断都靠它,不计就等于没有预算
-          await taskStore.addConsumption(input.taskId, {
-            tokens: result.usage.inputTokens + result.usage.outputTokens,
-          });
-          // 解析与校验归引擎(它才知道这一步声明了什么);这里只如实上交结果与原文
-          return {
-            ok: true,
-            ...(result.object === undefined ? {} : { object: result.object }),
-            text: result.text,
-          };
-        } catch (error) {
-          return { ok: false, error: error instanceof Error ? error.message : String(error) };
-        }
-      },
-    },
-    cards,
-    listeners,
-    memory: memoryRecorder as never,
-    tasks: taskContext,
-    clock,
-  });
-
   /**
    * 模型网关加观测:每次模型调用一个 span(用途名、标签、用量)——
    * 「活动内部到底问了几次模型」在时间轴上要看得见。
@@ -616,7 +573,7 @@ export function wireEngines(deps: EngineWiringDeps): EngineWiring {
     return ports;
   }
 
-  /* ── task(L6):范式在此汇流,对上层不可区分 ──────────────────── */
+  /* ── task(L6):活动的运行时 —— 只有一种引擎(2026-07-29 起) ────── */
   const task = createTaskService({
     store: taskStore,
     activities: {
@@ -624,7 +581,6 @@ export function wireEngines(deps: EngineWiringDeps): EngineWiring {
         const manifest = await deps.registry.manifestOf(activityId);
         const envelope = await deps.registry.loadEnvelope(activityId);
         return {
-          paradigm: manifest.identity.paradigm,
           caps: manifest.contract.resources.budget,
           envelope: { ...envelope },
           inputSchema: manifest.contract.input.data,
@@ -634,46 +590,27 @@ export function wireEngines(deps: EngineWiringDeps): EngineWiring {
       },
     },
     schemas: deps.schemas,
-    // 范式在此汇流:两个引擎按统一的 ParadigmEngine 契约暴露给 task —— 对上层不可区分(§9)
-    engines: {
-      loop: {
-        load: (taskId, model) => loop.load(taskId, model as never).then(() => undefined),
-        advance: async (taskId) => {
-          const outcome = await loop.runTurn(taskId);
-          return {
-            status: outcome.status,
-            ...(outcome.blockedReason === undefined ? {} : { reason: outcome.blockedReason }),
-            // 终局唯放行:runTurn 依在途验收的裁决给出 finished 时,released/选口一并带回
-            ...(outcome.released === undefined ? {} : { released: outcome.released }),
-            ...(outcome.selectedPorts === undefined ? {} : { selectedPorts: outcome.selectedPorts }),
-          };
-        },
-        // 只记不跑:登记事件/收裁决即返,推进统一归 deliver 随后的 tick —— 预算一个口径
-        onEvent: async (taskId, event) => {
-          await loop.onEvent(taskId, event);
-          return { status: 'running' as const };
-        },
+    /*
+     * 唯一的引擎(2026-07-29 用户定:活动不再分 flow 和 loop,内部实现都是 Loop)。
+     * 从前这里是两个引擎按 paradigm 分派;flow 那一路连同 flow-engine 模块一并退役 ——
+     * 一件事该怎么办由 Agent 依案例模型临场决定,不再有「照谱执行」的第二种活动。
+     */
+    engine: {
+      load: (taskId, model) => loop.load(taskId, model as never).then(() => undefined),
+      advance: async (taskId) => {
+        const outcome = await loop.runTurn(taskId);
+        return {
+          status: outcome.status,
+          ...(outcome.blockedReason === undefined ? {} : { reason: outcome.blockedReason }),
+          // 终局唯放行:runTurn 依在途验收的裁决给出 finished 时,released/选口一并带回
+          ...(outcome.released === undefined ? {} : { released: outcome.released }),
+          ...(outcome.selectedPorts === undefined ? {} : { selectedPorts: outcome.selectedPorts }),
+        };
       },
-      flow: {
-        load: (taskId, model) => flow.load(taskId, model as never).then(() => undefined),
-        advance: async (taskId) => {
-          const outcome = await flow.advance(taskId);
-          return {
-            status: outcome.status,
-            ...(outcome.blockedReason === undefined ? {} : { reason: outcome.blockedReason }),
-            // 谱走完时把放行裁决带上来 —— 完成只出自放行通过
-            ...(outcome.released === undefined ? {} : { released: outcome.released }),
-            ...(outcome.selectedPorts === undefined ? {} : { selectedPorts: outcome.selectedPorts }),
-          };
-        },
-        onEvent: async (taskId, event) => {
-          const outcome = await flow.resume(taskId, {
-            kind: event.kind === 'control' ? 'time' : event.kind,
-            ref: event.ref,
-            payload: event.payload,
-          });
-          return { status: outcome.status, ...(outcome.blockedReason === undefined ? {} : { reason: outcome.blockedReason }) };
-        },
+      // 只记不跑:登记事件/收裁决即返,推进统一归 deliver 随后的 tick —— 预算一个口径
+      onEvent: async (taskId, event) => {
+        await loop.onEvent(taskId, event);
+        return { status: 'running' as const };
       },
     },
     landing: {
@@ -723,8 +660,7 @@ export function wireEngines(deps: EngineWiringDeps): EngineWiring {
     },
     persistence: {
       hasDrafts: async (taskId) => (await deps.ledger.checkConflicts(taskId)) !== undefined,
-      hasRuntimeState: async (taskId) =>
-        (await flow.position(taskId)) !== undefined || (await loop.runtime(taskId)) !== undefined,
+      hasRuntimeState: async (taskId) => (await loop.runtime(taskId)) !== undefined,
     },
     events: {
       publishControl: async (taskId, semantic, by, reason) => {