M5/M6 修复串:判据 ③ 全链路跑通 —— 六处「声明与引擎对不上」

判据 ③ 现在从入站到 released 一路走通:步序推进 → LLM 步(密钥是占位符,
按声明降级为人兜底)→ 台账草稿层 → D1 条件跳步 → S4 工具 → S5 DMN 三分类
(LM358DR → Type A · 直接快答)→ 验收放行 → 草稿合并正式版 2 行 → 输出口
intake 发射 → 终态 released。

沿路修掉的六处,每一处都是「声明是这么写的,引擎不这么读」:

1. 人兜底卡只问一个笼统「结果」框 → 改问**这一步声明的出参字段**。
   出参契约属于步、不属于执行者:同一步谁做完,落进作用域的形状都得一样。
2. 人事件的载荷是回传协议壳 `{mode,workOrderId,values}`,
   引擎把整个壳当出参写 → 取 `values`。
3. 引擎作用域是 `{'域.对象': 行数组}`,而所有活动的步声明写的都是裸字段名 →
   任务视图三层铺开:起单入参在底、各对象最新行的字段铺顶层、地址式整表保留。
4. 起单入参从不落库、也进不了作用域 → task 存 `input_data`,断点续跑后仍在。
5. 步出参无法声明**写哪一行** → 出参加 `key`(主键列 → 作用域路径);
   六个活动包的每处出参补上键。台账几乎都有主键,不声明键就只能写无主键行。
6. `tick` 不处理 `finished`:谱走完仍按 running 一拍拍推,把预算烧到 exhausted,
   把「没人裁」误报成「跑爆了」→ 放行通过则落地收敛后 released;未放行则挂起等人。
   `flow.advance` 据末步验收裁决报 released —— **完成只出自放行通过**。

另两处装配缺口:
  · `release.land()` 实现完整却无人调用 —— 放行后从不落地。经 LandingGateway 接上。
  · `process.onTaskTerminal()` 实现完整却无人调用 —— 任务终态报不到流程层,
    流就停在那个节点上,既不流转也不走失败走向。task 在 L6 不得反向依赖 L7,
    这一跳由 app 缝合(延后绑定,同 container 里 TriggerMatcher 的手法)。

还有一处版本化缺陷:资产播种恒用 v1,`shouldSeedAsset` 一比就跳过 ——
只有**第一个**包版本的资产此生有效,之后装什么都跑旧的。改为播下一版;
进化管线放行出的更高版仍不被盖过;同版重复安装不再播种。

gates: tsc / eslint / depcruise(317 模块)/ api-report / 393 测试 全绿

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

apps/api/src/modules/task/contract.ts

@@ -55,6 +55,8 @@ export type Task = {
   readonly reason?: string;
   /** 装载信封:包版本 + 各资产生效版 —— 行为可归因 */
   readonly envelope: Readonly<Record<string, unknown>>;
+  /** 起单入参:契约的 data —— 引擎求值的作用域底料 */
+  readonly data: Readonly<Record<string, unknown>>;
   readonly caps: BudgetCaps;
   readonly used: Consumption;
   readonly startedAt: string;

apps/api/src/modules/task/internal/adapter/task-schema.ts

@@ -21,6 +21,8 @@ export const taskTable = sys.table(
     reason: text('reason'),
     /** 装载信封:包版本 + 各资产生效版 —— 行为可归因 */
     envelope: jsonb('envelope').notNull(),
+    /** 起单入参 —— 步序声明按字段名读它;不存下来,断点续跑后作用域就空了 */
+    inputData: jsonb('input_data').notNull().default({}),
     caps: jsonb('caps').notNull(),
     usedSteps: integer('used_steps').notNull().default(0),
     usedTokens: integer('used_tokens').notNull().default(0),

apps/api/src/modules/task/internal/adapter/task-store.ts

@@ -24,6 +24,7 @@ function toTask(row: Row): Task {
     ...(row.terminal === null ? {} : { terminal: row.terminal as TerminalState }),
     ...(row.reason === null ? {} : { reason: row.reason }),
     envelope: row.envelope as Record<string, unknown>,
+    data: row.inputData as Record<string, unknown>,
     caps: row.caps as BudgetCaps,
     used: {
       steps: row.usedSteps,
@@ -49,6 +50,7 @@ export function createTaskStore(db: Db): TaskStore {
         title: task.title,
         runtime: task.runtime,
         envelope: task.envelope,
+        inputData: task.data,
         caps: task.caps,
         startedAt: new Date(task.startedAt),
       });

apps/api/src/modules/task/internal/usecase/task-service.ts

@@ -12,6 +12,7 @@ import type {
   Clock,
   IdGenerator,
   InteractionPhaseSetter,
+  LandingGateway,
   ListenerProbe,
   MemoryRecorder,
   ParadigmEngine,
@@ -31,6 +32,8 @@ export type TaskServiceDeps = {
   /** 范式引擎按 paradigm 分派 —— 对上层不可区分 */
   readonly engines: Readonly<Record<'loop' | 'flow', ParadigmEngine>>;
   readonly memory: MemoryRecorder;
+  /** 落地收敛 —— 放行通过的那一刻才碰事实 */
+  readonly landing: LandingGateway;
   readonly listeners: ListenerProbe;
   readonly persistence: PersistenceProbe;
   readonly events: TaskEventPublisher;
@@ -80,6 +83,7 @@ export function createTaskService(deps: TaskServiceDeps): TaskService {
         ownerId: input.ownerId,
         title: input.title,
         runtime: 'running',
+        data: input.data,
         envelope: loaded.envelope,
         caps: loaded.caps,
         used: ZERO_CONSUMPTION,
@@ -147,6 +151,38 @@ export function createTaskService(deps: TaskServiceDeps): TaskService {
         const finished = await this.finish(taskId, { kind: 'blocked', reason: outcome.reason ?? '无法推进' });
         return { task: finished, verdict, progressed: true };
       }
+
+      /*
+       * 谱走完了。**完成只出自放行通过**(OS 05):
+       *   · 放行通过 → 落地收敛(草稿合并 + 动作执行 → 收敛才发射输出口)→ released;
+       *   · 未放行(还没裁 / 驳回)→ 不是完成,也**不再空推** —— 挂起等人,
+       *     否则推进器会一拍一拍把预算烧到 exhausted,把「没人裁」误报成「跑爆了」。
+       */
+      if (outcome.status === 'finished') {
+        if (outcome.released !== true) {
+          const waiting = await deps.store.update(taskId, { runtime: 'awaiting-human' });
+          await deps.interaction.setPhase(taskId, 'awaiting-event');
+          return { task: waiting, verdict, progressed: false };
+        }
+        const landed = await deps.landing.land({
+          taskId,
+          ownerId: task.ownerId,
+          humanCallCap: task.caps.humanCalls,
+        });
+        if (!landed.converged) {
+          // 落地未收敛:输出口不得发射,任务受阻待人(落地失败卡已发)
+          const blocked = await this.finish(taskId, { kind: 'blocked', reason: '落地未收敛,输出口未发射' });
+          return { task: blocked, verdict, progressed: true };
+        }
+        await deps.memory.append({
+          taskId,
+          kind: 'engine-transition',
+          title: `落地收敛:合并 ${landed.ledgerRowsMerged} 行,发射输出口 ${landed.emittedPorts.join('、') || '—'}`,
+        });
+        const finished = await this.finish(taskId, { kind: 'released' });
+        return { task: finished, verdict, progressed: true };
+      }
+
       return { task: updated, verdict, progressed: true };
     },
 

apps/api/src/modules/task/port.ts

@@ -38,11 +38,30 @@ export type SchemaValidator = {
 /** 范式引擎 —— loop / flow 在此汇流;对上层不可区分(§9 双层边界) */
 export type ParadigmEngine = {
   load(taskId: TaskId, model: unknown): Promise<void>;
-  advance(taskId: TaskId): Promise<{ status: 'running' | 'awaiting' | 'submitted' | 'finished' | 'blocked'; reason?: string }>;
+  advance(taskId: TaskId): Promise<EngineOutcome>;
   onEvent(
     taskId: TaskId,
     event: { kind: 'data' | 'time' | 'human' | 'control'; ref: string; payload: Record<string, unknown> },
-  ): Promise<{ status: 'running' | 'awaiting' | 'submitted' | 'finished' | 'blocked'; reason?: string }>;
+  ): Promise<EngineOutcome>;
+};
+
+export type EngineOutcome = {
+  readonly status: 'running' | 'awaiting' | 'submitted' | 'finished' | 'blocked';
+  readonly reason?: string;
+  /** 谱走完时:放行是否通过 —— **完成只出自放行通过**,引擎不自行宣布完成 */
+  readonly released?: boolean;
+};
+
+/**
+ * 落地收敛 —— app 注入 `release`(L4)。
+ * 放行通过的那一刻才落地:草稿合并入正式版、动作意向执行、收敛后才发射输出口。
+ */
+export type LandingGateway = {
+  land(input: { taskId: TaskId; ownerId: StaffId; humanCallCap: number }): Promise<{
+    converged: boolean;
+    emittedPorts: readonly string[];
+    ledgerRowsMerged: number;
+  }>;
 };
 
 export type MemoryRecorder = {