三面拆分⑮:对齐 Mastra 数据流 —— 边只表达顺序,数据按输入/输出字段名流动

用户定的机制对齐:Mastra 的边不传数据,所有约束力靠输入/输出字段(schema 咬合)完成。
照此把「边映射」整个退役:

  · 契约:edge 去 mapping,审批 reject 去 mapping —— 边只剩 顺序 + 条件(读上游
    输出字段)+ 标签/回边。fieldMapping 只留给触发器的起单装配(系统边界)。
    存量包无需迁移:zod 解析时把旧 jsonb 里的 mapping 静默剥掉,图照常有效。
  · 运行时:assemble(边装配)→ flatScope(铺平作用域)——
    起单入参垫底 ← 沿途各输出口字段依次盖上 ← 刚发射的载荷(Mastra 语义:
    下一步的 input 首先是上一步的 output)。下游按自己的契约取字段;
    「__」前缀是运行时自留地,不入业务作用域。审批驳回重开、失败改道同一条路。
  · 闭合校验:边未映射/必填未映射/容忍依赖三条映射类检查退役
    (宽进之下必填有没有着落是运行时补全单的事,不拦激活);
    激活闸只留一条硬伤 —— **同名不同型**:名字即管道,名同型异必坏,
    容忍依赖改按名判。改名映射不存在:名不对改契约,不是加映射。
  · 种子:A2 的入参 material 更名 pn(它就是 PN;上游 A1 发的名就得是它收的名),
    契约 0.3.0、槽位 0.8.0;流程种子边全部去映射。
  · 前端:边属性卡砍掉「映射 · 载荷装配」整节,只剩 E号/方向/条件/标签;
    节点属性卡新增「数据接口 · 按字段名流动」——每个输入字段标出运行时从哪来
    (起单入参 / 上游 X / 补全单),输出口列出发什么名;沿边回溯推导,设计期看得见。
    画布保存与依赖文件导出同步去映射。

E2E 顺带把宽进接进真流:快速归档流的 A3 要 outcome 而流里没人产 ——
测试如实走补全路(等人 → 答卡 outcome=won → 开跑 → completed)。
实测走查:A2 节点卡上 pn←上游A1、rfqRef←起单入参、scenario←补全单,推导全对。

五闸绿;契约快照随本提交入库。

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

apps/web/src/app/styles/console.css

@@ -665,6 +665,19 @@
 .g-maprow > .g-btn { grid-column: 6; justify-self: stretch; padding: 4px 0; display: inline-flex; align-items: center; justify-content: center; }
 .g-maparr { color: var(--sh-steel, #46586a); font-weight: 700; text-align: center; }
 
+/* ── 节点属性 · 数据接口:契约即管道 —— 输入字段(名/型/来源)+ 输出口 ── */
+.g-dif { display: flex; flex-direction: column; gap: 2px; }
+.g-dif + .g-dif { margin-top: 8px; }
+.g-dif > em { font: 600 9px/1.6 var(--mono); font-style: normal; letter-spacing: .1em; text-transform: uppercase; color: var(--ink-4); padding-bottom: 3px; border-bottom: 1px solid var(--line-soft); }
+.g-dif-r { display: flex; align-items: baseline; flex-wrap: wrap; gap: 4px 10px; padding: 4px 0; border-bottom: 1px dashed var(--line-soft); font-size: 11.5px; }
+.g-dif-r:last-child { border-bottom: 0; }
+.g-dif-r .k { font-family: var(--mono); font-weight: 700; color: var(--ink); }
+.g-dif-r .k i { font-style: normal; font-family: var(--mono); font-size: 8.5px; font-weight: 600; letter-spacing: .06em; color: #8a5f1c; margin-left: 5px; padding: 1px 4px; border: 1px solid #e3d1a8; border-radius: 3px; }
+.g-dif-r .t { font-family: var(--mono); font-size: 10px; color: var(--ink-4); }
+.g-dif-r .s { margin-left: auto; font-size: 11px; color: var(--ink-3); }
+.g-dif-r .s.ask { color: #8a5f1c; }
+.g-dif-r .f { min-width: 0; font-family: var(--mono); font-size: 10.5px; color: var(--ink-3); overflow-wrap: anywhere; }
+
 /* ── 运营中心 · 工作流 · 运行配置:一包一卡,里面两节(触发器 / 节点负责人)── */
 .g-runconf { display: flex; flex-direction: column; gap: 4px; padding: 10px 14px 12px; }
 .g-runconf + .g-runconf { border-top: 1px dashed var(--line-soft); }

apps/web/src/features/gov-process/internal/panel.tsx

@@ -25,7 +25,6 @@ import {
   Chip,
   Field,
   Kpi,
-  ListEdit,
   Note,
   PageHead,
   Prop,
@@ -65,24 +64,20 @@ function flowsOf(packages: readonly ProcessPackage[]) {
   });
 }
 
-/* ── 边属性:传递契约(条件 + 映射)──────────────────────────────────── */
-
-/** 映射行的工作形状 —— 语义边 mapping 的元素;设计者只见三种来源,其余是系统隐性上下文 */
-type MapRow = { target: string; source: Record<string, unknown> & { from: string } };
-const SOURCE_KINDS = [
-  { k: 'output-port', label: '上游输出口' },
-  { k: 'initiation', label: '起单载荷' },
-  { k: 'constant', label: '常量' },
-] as const;
+/* ── 边属性:只剩顺序与条件(2026-07-30 对齐 Mastra)────────────────────
+   Mastra 的边不传数据 —— 约束力全在两端活动的输入/输出字段(schema 咬合)。
+   数据按字段名流动:上游发的名就是下游收的名;边属性卡因此只剩条件与标签,
+   「映射 · 载荷装配」整节退役 —— 下游拿什么去**节点属性**的数据接口看。 */
 
 function EdgeProps({ edge, onPatch }: { edge: FlowEdge; onPatch: (f: (e: FlowEdge) => FlowEdge) => void }) {
-  const rows = (edge.mapping ?? []) as MapRow[];
-  const setRows = (next: MapRow[]) => onPatch((e) => ({ ...e, mapping: next }));
-  const patchRow = (i: number, f: (r: MapRow) => MapRow) => setRows(rows.map((r, j) => (j === i ? f(r) : r)));
   return (
     <div className="g-props g-eprops">
-      <Prop ico="git-branch" title={`${edge.code ?? '边'} · ${edge.from} → ${edge.to}`} extra="多出边异或:命中即走;条件留空 = 默认兜底">
-        <Field k="S-FEEL 条件" hint="如 needSourcing = true;可用 and / or 连接。留空即无条件(默认边,至多一条)">
+      <Prop
+        ico="git-branch"
+        title={`${edge.code ?? '边'} · ${edge.from} → ${edge.to}`}
+        extra="边只表达顺序与条件 —— 数据按字段名自动流动"
+      >
+        <Field k="S-FEEL 条件" hint="读上游节点的输出字段,如 needSourcing = true;留空即无条件(默认边,至多一条)">
           <input
             className="g-input mono"
             value={edge.condition ?? ''}
@@ -104,101 +99,6 @@ function EdgeProps({ edge, onPatch }: { edge: FlowEdge; onPatch: (f: (e: FlowEdg
           />
         </Field>
       </Prop>
-      <Prop ico="git-merge" title="映射 · 载荷装配" extra="必填映射齐了这条边才闭合">
-        {/* 明细表列头:行与列头同一 6 列栅格;非「上游输出口」的来源在口/路径两列上合并 */}
-        <div className="g-maphead" aria-hidden="true">
-          <span>下游字段</span>
-          <span className="a">←</span>
-          <span>来源</span>
-          <span>口名</span>
-          <span>路径 · 值</span>
-          <span />
-        </div>
-        {rows.map((r, i) => {
-          const known = SOURCE_KINDS.some((k) => k.k === r.source.from);
-          return (
-            <div className="g-maprow" key={i}>
-              <input
-                className="g-input mono"
-                value={r.target}
-                placeholder="下游字段"
-                onChange={(e) => patchRow(i, (x) => ({ ...x, target: e.target.value }))}
-              />
-              <span className="g-maparr">←</span>
-              {known ? (
-                <select
-                  className="g-select"
-                  value={r.source.from}
-                  onChange={(e) =>
-                    patchRow(i, (x) => ({
-                      ...x,
-                      source:
-                        e.target.value === 'output-port'
-                          ? { from: 'output-port', port: '', path: '' }
-                          : e.target.value === 'initiation'
-                            ? { from: 'initiation', path: '' }
-                            : { from: 'constant', value: '' },
-                    }))
-                  }
-                >
-                  {SOURCE_KINDS.map((k) => (
-                    <option key={k.k} value={k.k}>
-                      {k.label}
-                    </option>
-                  ))}
-                </select>
-              ) : (
-                // workflow-var / expression 等是系统侧来源 —— 保留展示,不给编辑入口
-                <Chip tone="mute">{String(r.source.from)}(系统)</Chip>
-              )}
-              {r.source.from === 'output-port' && (
-                <>
-                  <input
-                    className="g-input mono"
-                    value={String(r.source['port'] ?? '')}
-                    placeholder="口名"
-                    onChange={(e) => patchRow(i, (x) => ({ ...x, source: { ...x.source, port: e.target.value } }))}
-                  />
-                  <input
-                    className="g-input mono"
-                    value={String(r.source['path'] ?? '')}
-                    placeholder="字段路径"
-                    onChange={(e) => patchRow(i, (x) => ({ ...x, source: { ...x.source, path: e.target.value } }))}
-                  />
-                </>
-              )}
-              {r.source.from === 'initiation' && (
-                <input
-                  className="g-input mono wide"
-                  value={String(r.source['path'] ?? '')}
-                  placeholder="起单字段路径"
-                  onChange={(e) => patchRow(i, (x) => ({ ...x, source: { ...x.source, path: e.target.value } }))}
-                />
-              )}
-              {r.source.from === 'constant' && (
-                <input
-                  className="g-input mono wide"
-                  value={String(r.source['value'] ?? '')}
-                  placeholder="常量值"
-                  onChange={(e) => patchRow(i, (x) => ({ ...x, source: { ...x.source, value: e.target.value } }))}
-                />
-              )}
-              <button className="g-btn" onClick={() => setRows(rows.filter((_, j) => j !== i))}>
-                <Ico name="x" s={12} />
-              </button>
-            </div>
-          );
-        })}
-        <Acts
-          items={[
-            {
-              label: '加一条映射',
-              ico: 'plus',
-              onClick: () => setRows([...rows, { target: '', source: { from: 'output-port', port: '', path: '' } }]),
-            },
-          ]}
-        />
-      </Prop>
     </div>
   );
 }
@@ -506,6 +406,49 @@ function FlowLab({
             (node.act === undefined && semanticNode?.kind === 'activity' && a.activityId === semanticNode.activityId),
         );
 
+  /*
+   * 数据接口的来源推导(对齐 Mastra 名流动):这个节点的每个输入字段,运行时会从哪来 ——
+   *   ① 起单入参里有同名字段 → 起单带进;② 某个上游(沿边回溯)的输出口发同名字段 → 上游发;
+   *   ③ 都没有 → 受理归一时派补全单找人收。设计期看得见,不必等跑起来猜。
+   */
+  const fieldSources = (() => {
+    if (node === null) return new Map<string, string>();
+    const initFields = new Set(
+      Object.keys(((pkg.callInterface.input as { properties?: Record<string, unknown> }).properties ?? {})),
+    );
+    // 祖先集:沿边回溯(含回边,访问集防环)
+    const ancestors = new Set<string>();
+    const queue = [node.id];
+    while (queue.length > 0) {
+      const cur = queue.pop()!;
+      for (const e of graph?.edges ?? []) {
+        if (e.to !== cur || ancestors.has(e.from)) continue;
+        ancestors.add(e.from);
+        queue.push(e.from);
+      }
+    }
+    const actOf = (nid: string): string | undefined => {
+      const g = nodes.find((x) => x.id === nid);
+      if (g?.act !== undefined) return g.act;
+      const sem = pkg.nodes.find((x) => x.id === nid);
+      return sem?.kind === 'activity' ? sem.activityId : undefined;
+    };
+    const out = new Map<string, string>();
+    for (const f of refAct?.contract.inputFields ?? []) {
+      if (initFields.has(f.name)) {
+        out.set(f.name, '起单入参');
+        continue;
+      }
+      const from = [...ancestors].find((nid) =>
+        activities
+          .find((a) => a.activityId === actOf(nid))
+          ?.contract.outputPorts.some((port) => port.fields.includes(f.name)),
+      );
+      out.set(f.name, from !== undefined ? `上游 ${from}` : '补全单');
+    }
+    return out;
+  })();
+
   // 每次进页问一次闭合 —— 画图即校验(与后端裁决同源);落笔保存后用返回的报告
   const liveReport = useQuery({
     queryKey: ['gov', 'process-report', pkg.id, pkg.version],
@@ -661,17 +604,16 @@ function FlowLab({
           label: n.label,
           activityId: n.activityId,
           // 契约不带负责人岗位 —— 分派归运营,依赖文件只描述干什么
-          // 编排上手写的注记(给人读)
-          declaredIn: n.in ?? [],
-          declaredOut: n.out ?? [],
           /*
            * 活动库里那份**真契约**:必填入参、字段、输出口、声明的工具/模型/域对象。
            * 开发者照着它写实现;只给注记的话,依赖文件说不清这个活动到底要什么。
            */
           contract: actContract.get(n.activityId) ?? null,
-          upstreamAssembly: pkg.edges
-            .filter((e) => e.to === n.id)
-            .map((e) => ({ from: e.from, mapping: e.mapping })),
+          /*
+           * 数据按字段名流动(对齐 Mastra):依赖文件不再列边映射 ——
+           * 上游从哪来,看 contract.input 的字段名对上游 output 的字段名。
+           */
+          upstream: pkg.edges.filter((e) => e.to === n.id).map((e) => e.from),
         })),
       approvals: pkg.nodes
         .filter((n) => n.kind === 'approval')
@@ -1038,22 +980,50 @@ function FlowLab({
                   )}
                 </Prop>
 
-                {node.kind === 'activity' && (
-                  <Prop ico="git-merge" title="输入" extra="上游边映射的落点">
-                    <ListEdit
-                      items={node.in ?? []}
-                      placeholder="如:客户邮件"
-                      onChange={(v) => patch((n) => ({ ...n, in: v.length > 0 ? [...v] : undefined }))}
-                    />
-                  </Prop>
-                )}
-                {node.kind === 'activity' && (
-                  <Prop ico="upload" title="输出口" extra="下游边映射的源">
-                    <ListEdit
-                      items={node.out ?? []}
-                      placeholder="如:受理记录"
-                      onChange={(v) => patch((n) => ({ ...n, out: v.length > 0 ? [...v] : undefined }))}
-                    />
+                {node.kind === 'activity' && node.flavor !== 'approval' && (
+                  /*
+                   * 数据接口(对齐 Mastra):边不传数据,约束力全在输入/输出字段 ——
+                   * 这里不填写、只**看清**:每个输入字段运行时从哪来(起单 / 上游同名 / 补全单),
+                   * 每个输出口发什么名。要改字段,改的是活动契约,不是这张卡。
+                   */
+                  <Prop
+                    ico="git-merge"
+                    title="数据接口 · 按字段名流动"
+                    extra={refAct === undefined ? '先链接活动实现' : '契约即管道:名字对上,数据就到'}
+                  >
+                    {refAct === undefined ? (
+                      <Note>链接活动实现后,这里列出它吃什么、吐什么、每个字段从哪来。</Note>
+                    ) : (
+                      <>
+                        <div className="g-dif">
+                          <em>输入 · {refAct.contract.inputFields.length} 字段</em>
+                          {refAct.contract.inputFields.map((f) => {
+                            const src = fieldSources.get(f.name) ?? '补全单';
+                            return (
+                              <div key={f.name} className="g-dif-r">
+                                <span className="k">
+                                  {f.name}
+                                  {f.required && <i>必填</i>}
+                                </span>
+                                <span className="t">{f.type}</span>
+                                <span className={'s' + (src === '补全单' ? ' ask' : '')}>
+                                  {src === '补全单' ? '← 补全单(受理归一找人收)' : `← ${src}`}
+                                </span>
+                              </div>
+                            );
+                          })}
+                        </div>
+                        <div className="g-dif">
+                          <em>输出 · {refAct.contract.outputPorts.length} 口</em>
+                          {refAct.contract.outputPorts.map((port) => (
+                            <div key={port.name} className="g-dif-r">
+                              <span className="k">{port.name}</span>
+                              <span className="f">{port.fields.length > 0 ? port.fields.join(' · ') : '(整包事实)'}</span>
+                            </div>
+                          ))}
+                        </div>
+                      </>
+                    )}
                   </Prop>
                 )}
                 </div>

apps/web/src/shared/gov/flow/__tests__/graph-to-pkg.test.ts

@@ -25,11 +25,11 @@ const basePkg: ProcessPackage = processPackageSchema.parse({
     { id: 'E', kind: 'end', label: '终' },
   ],
   edges: [
-    { id: 'E1', from: 'S', to: 'A', mapping: [{ target: 'x', source: { from: 'initiation', path: 'x' } }] },
-    { id: 'E2', from: 'A', to: 'B', mapping: [] },
+    { id: 'E1', from: 'S', to: 'A' },
+    { id: 'E2', from: 'A', to: 'B' },
     // 乙的两条互斥出边:通过 → 终点;有异议 → 回甲重开(无网关:分支就在节点身上)
-    { id: 'E3', from: 'B', to: 'E', condition: 'ok = true', mapping: [] },
-    { id: 'E4', from: 'B', to: 'A', condition: 'ok = false', mapping: [], reopen: true },
+    { id: 'E3', from: 'B', to: 'E', condition: 'ok = true' },
+    { id: 'E4', from: 'B', to: 'A', condition: 'ok = false', reopen: true },
   ],
   variables: [],
 });
@@ -73,9 +73,8 @@ describe('mergeGraphIntoPackage', () => {
     expect(minted.sort()).toEqual(['E5', 'E6']);
   });
 
-  it('画布装不下的声明原样保留:边映射与失败走向', () => {
+  it('画布装不下的声明原样保留:失败走向(边映射已随「名流动」退役)', () => {
     const merged = mergeGraphIntoPackage(basePkg, graph);
-    expect(merged.edges.find((e) => e.id === 'E1')?.mapping).toHaveLength(1);
     const a = merged.nodes.find((n) => n.id === 'A');
     expect(a?.kind === 'activity' && a.failure.kind).toBe('terminate');
   });
@@ -95,12 +94,12 @@ describe('mergeGraphIntoPackage', () => {
     expect(b?.kind === 'activity' && b.activityId).toBe('act-b');
   });
 
-  it('边的条件/映射工作副本优先;清空条件 = 变默认兜底边', () => {
+  it('边的条件工作副本优先;清空条件 = 变默认兜底边', () => {
     const edited: FlowGraph = {
       ...graph,
       edges: graph.edges.map((e) =>
         e.from === 'B' && e.to === 'E'
-          ? { ...e, condition: 'ok = true and sum > 3', mapping: [{ target: 'y', source: { from: 'initiation', path: 'y' } }] }
+          ? { ...e, condition: 'ok = true and sum > 3' }
           : e.from === 'B' && e.to === 'A'
             ? { ...e, condition: '' } // 设计者把条件清空:这条边成了默认兜底
             : e,
@@ -109,10 +108,7 @@ describe('mergeGraphIntoPackage', () => {
     const merged = mergeGraphIntoPackage(basePkg, edited);
     const pass = merged.edges.find((e) => e.id === 'E3');
     expect(pass?.condition).toBe('ok = true and sum > 3');
-    expect(pass?.mapping).toHaveLength(1);
     const back = merged.edges.find((e) => e.id === 'E4');
     expect(back?.condition).toBeUndefined();
-    // 没动过的边沿用旧声明
-    expect(merged.edges.find((e) => e.id === 'E1')?.mapping).toHaveLength(1);
   });
 });

apps/web/src/shared/gov/flow/graph-to-pkg.ts

@@ -103,13 +103,12 @@ export function mergeGraphIntoPackage(
     .filter((e) => semanticIds.has(e.from) && semanticIds.has(e.to))
     .map((e) => {
       const prior = priorEdge.get(`${e.from}→${e.to}`);
-      // 边属性(传递契约)以属性卡的工作副本优先;没动过的沿用旧声明
+      // 边只带顺序与条件(对齐 Mastra):条件以属性卡的工作副本优先;没动过的沿用旧声明
       const condition = e.condition !== undefined ? (e.condition.trim() === '' ? undefined : e.condition) : prior?.condition;
       return {
         id: prior?.id ?? `E${nextEdgeNo++}`,
         from: nodeIdSchema.parse(e.from),
         to: nodeIdSchema.parse(e.to),
-        mapping: (e.mapping as Edge['mapping'] | undefined) ?? prior?.mapping ?? [],
         ...(condition === undefined ? {} : { condition }),
         reopen: prior?.reopen ?? false,
         ...(e.label === undefined ? {} : { label: e.label }),

apps/web/src/shared/gov/flow/pkg-to-graph.ts

@@ -71,7 +71,6 @@ export function packageToGraph(pkg: ProcessPackage, marks: readonly InstanceMark
         ...e,
         code: sem.id as string,
         ...(sem.condition === undefined ? {} : { condition: sem.condition }),
-        mapping: sem.mapping as unknown[],
       };
     });
     return { ...stored, edges, nodes: [...withState(stored.nodes), ...withState(extras)] };

apps/web/src/shared/gov/gov-route.ts

@@ -121,7 +121,7 @@ export const ZM: Readonly<Record<GovZone, { title: string; desc: string; accent:
     title: '流程包管理',
     icon: 'workflow',
     accent: 'linear-gradient(140deg,#4954e6,#3a44c9)',
-    desc: '战略——企业以哪些流转运转。一条流一个包,版本收在包内部:画图不检查、激活才查完整,恰一个生效版本、在途按启动版本跑完。编排即定契约:连线即映射,分支就是条件出边。触发器(谁调起这条流)也在本区定义;启停在运营中心。',
+    desc: '战略——企业以哪些流转运转。一条流一个包,版本收在包内部:画图不检查、激活才查完整,恰一个生效版本、在途按启动版本跑完。边只表达顺序与条件(对齐 Mastra),数据按输入/输出字段名流动——约束力在两端活动契约上。触发器已独立成区;启停在运营中心。',
   },
   library: {
     title: '活动库',