测试台改仪表台:启动输入换成一封信;卡片化触发器与大模型;清掉 ⓘ 说教条

**测试台**
  · 启动输入不再是「调用参数」表 —— 这条流真实的起法就是客户来信,
    界面上就该是一封信(发件人 / 收件人 / 主题 / 正文 / BOM 附件)。
    服务端拿**真通道的抽键正则** + **真触发器的装配映射**推出调用入参:
    测试台自己不解析邮件,否则试通的是测试台而不是这条流。
    抽不出必填就如实报「哪个字段没命中、通道的正则要什么」,不静默起空单。
  · 一屏两大块:左选流,右两节 —— 01 输入配置、02 节点指派。
  · 起单钮只剩一枚(原来页头一枚、RUN 卡里一枚)。
  · 改暗色仪表台:调色板集中在 .g-tb/.g-rig 的一组变量上,
    TRACE 那张树 + 甘特的结构一行没动,只是纸变成了面板。

**触发器 / 大模型** 列表改卡片:一条规则、一个实例都要一眼看全
(何时起 · 起哪条流 · 开没开 / 谁家的 · 什么型号 · 密钥绑没绑)。
触发器卡是 div 不是 button —— 卡里还坐着「改规则」那枚真按钮。

**同类卡等高**:底栏钉在卡底、说明恒占两行、卡头一行截断。
实测同一货架内 13 张工具卡、6 张活动卡、3 张模型卡各自完全等高。

**删掉 19 条 ⓘ 说教横幅**(「只列有生效版的包…」那一类)。
留下的是三种:确认带里的影响说明(点了动作才出现,是决策依据)、
warn/ok 的真反馈、以及「X 不存在」这类空态。

删掉入站邮件演练整屏 —— 它验的那两步已经并进测试台的起单路径了。

新增一条接缝测试:通道抽出来的键叫 keys.customerCode,触发器映射也得照这名字取;
哪头改了名字单还是能起,只是入参悄悄变空、流走到 G1 才莫名其妙地停。

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

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KeDBx2PHLavbURXB8LJJ7m
This commit is contained in:
2026-07-29 10:42:01 +08:00
co-authored by Claude Opus 5
parent 331fd25922
commit 72f90f293b
19 changed files with 526 additions and 838 deletions
@@ -269,13 +269,7 @@ function InstallCard() {
</button>
}
>
<Note>
交<b>清单</b>(manifest.json)+ <b>产物</b>(index.js)两份文件,两审当场跑:
静态审读清单(工具契约在否、模型名绑没绑、声明与已物化台账冲不冲),
回放审重演历史成功单 —— <b>旧成不坏</b>是生效硬门,首装无历史即免。
恒为新增、版本并存:装入不覆盖旧版本,在途任务按启动时版本跑完。
</Note>
</Card>
</Card>
);
}
@@ -32,11 +32,6 @@ export function DataHome({ nav }: HomeProps) {
return (
<QueryGate query={q}>
<>
<Note>
数据按<b>经营对象</b>四分:<b>项目</b>是每一单的流转单据(受理记录 → 比价 → 草案 → 报价单),
<b>客户 / 情报 / 供应商</b>是跨单沉淀的资产。域是承载的划分,对象由活动声明物化 ——
最大化合并、只增不破坏。这里改结构;<b>行数据在运营中心 · 台账看</b>。
</Note>
{domains.map((d) => {
const inDomain = objects.filter((o) => o.domain === d);
return (
@@ -87,10 +82,6 @@ export function LedgersHome({ tab, nav }: HomeProps) {
return (
<QueryGate query={q}>
<>
<Note>
<b>{domainShort(domain)}</b>域(<span className="g-mono">{domain}</span>)的行数据、主键与列结构。
结构要改去设计中心 · 数据域;这里做的是运营动作 —— 查行、看版本、追引用。
</Note>
{inDomain.length === 0 ? (
<Clear>这个域还没有对象 —— 对象随活动首次写入而物化,建好就出现在这里。</Clear>
) : (
@@ -176,10 +176,6 @@ export function KnowledgeHome({ nav }: HomeProps) {
return (
<>
<Note>
活动记忆四层:<b>事实层 / 模式层 / 裁决层 / 例外层</b>。写入唯蒸馏,条目必挂证据链;
记忆不载权力——强制力只经候选增量 + 回放 + 人放行进入业务模型。
</Note>
<div className="g-picker">
{(activities.data?.activities ?? []).map((a) => (
<button
@@ -243,12 +243,7 @@ function OverviewHome() {
{/* 网关已废除:分支 = 条件出边,不再是一种要素 */}
<Kpi ico="boxes" label="编排要素" value="四种" sub="活动 · 审批 · 触发器 · 流程包" />
</div>
<Note>
画图不检查,激活才查完整:随手画的都存得下(存出来不生效),异常清零后激活,
即刻对<b>新起的</b>工作流生效;在途的按启动时版本跑完。要回退,把生效切回旧版本 ——
一条流一次只有一个生效版本。
</Note>
</QueryGate>
</QueryGate>
);
}
@@ -68,9 +68,6 @@ function StaffHome({ tab, nav }: HomeProps) {
return (
<QueryGate query={q}>
<>
<Note>
停用前置检查:在途任务与待答卡须先<b>改派完毕</b>——停用不得让在途工作无人认领。
</Note>
<NList>
{staff.map((s) => {
const mine = (tasks.data?.tasks ?? []).filter((t) => t.ownerName === s.name && t.terminal === undefined);
@@ -5,6 +5,7 @@
* DOM 结构、类名(`g-*` + 色调 `t-*`)与文案原样保留,mock 常量换成服务端投影(README 平移规则 1/2/4)。
* 区首页只负责导航,治理动作一律落在下钻详情页的**就地确认带**(影响预览三必答)。
*/
import { Ico } from '@web-shared/Ico.tsx';
import { Card, Chip, NList, NRow, Note, PageHead, QueryGate, Rows, St } from '@web-shared/gov/primitives.tsx';
import type { Nav } from '@web-shared/gov/gov-route.ts';
import {
@@ -30,10 +31,6 @@ export function SystemHome({ tab, nav }: HomeProps) {
if (tab === 'chan') {
return (
<>
<Note>
通道实例声明<b>归属键规则</b>与默认认领岗位。归属解析三级逐级短路:会话线程 → 监听键 → 地址窗口;
歧义或失败一律判无主——<b>宁交人,不错投</b>。
</Note>
<NList>
{(channels.data?.channels ?? []).map((ch) => (
<NRow
@@ -64,31 +61,37 @@ export function SystemHome({ tab, nav }: HomeProps) {
return (
<QueryGate query={llm}>
<>
<Note>
LLM 实例是<b>名称间接层</b>:活动只见自定义模型名,Provider / URL / API-Key / Model 四元在系统侧绑定。
密钥与 endpoint 值只存治理台——不入包、不入活动、不入留痕明文。
</Note>
<NList>
{/* 卡而不是行:一个实例要一眼看全「谁家的 · 什么型号 · 密钥绑没绑」 */}
<div className="g-shelf">
{(llm.data?.instances ?? []).map((i) => (
<NRow
<button
key={i.id}
tone={i.enabled ? 'brand' : 'mute'}
ico="cpu"
title={i.name}
sub={`${i.provider} · ${i.model}`}
cols={[
{ k: 'Base URL', v: <span className="g-mono">{i.baseUrl}</span> },
{ k: '系统用途', v: i.systemUse ? '是' : '—' },
]}
right={
className={'g-tile t-' + (i.enabled ? 'brand' : 'mute')}
onClick={() => nav.push({ k: 'llm', id: i.id })}
>
<span className="g-tile-h">
<span className="g-tile-i">
<Ico name="cpu" s={16} />
</span>
<span className="g-tile-t">
<b>{i.name}</b>
<em>{i.model}</em>
</span>
{i.systemUse && <Chip tone="brand">系统用途</Chip>}
</span>
<span className="g-tile-d">{i.baseUrl}</span>
<span className="g-tile-m">
<Chip ico="server">{i.provider}</Chip>
</span>
<span className="g-tile-f">
<St tone={i.apiKeyBound ? 'ok' : 'warn'} ico={i.apiKeyBound ? 'shield-check' : 'alert-triangle'}>
{i.apiKeyBound ? '密钥已绑定' : '密钥未绑定'}
</St>
}
onClick={() => nav.push({ k: 'llm', id: i.id })}
/>
<span className="r">{i.enabled ? '启用' : '停用'}</span>
</span>
</button>
))}
</NList>
</div>
</>
</QueryGate>
);
@@ -162,9 +162,6 @@ function RuntimeHome({ tab, nav }: HomeProps) {
if (tab === 'list') {
return (
<>
<Note>
任务 = 工作流上的节点,一个活动 = 一个任务;它派进员工工作台的<b>任务清单</b>,负责人由节点声明的岗位解析而来。
</Note>
<NList>
{tasks.map((t) => {
const st = t.terminal !== undefined ? TERMINAL_ST[t.terminal] : RUNTIME_ST[t.runtime];
@@ -445,7 +442,6 @@ export function TaskPage({ id, nav }: { id: string; nav: Nav }) {
</Card>
<Sec ico="user-plus" title="改派">
<Note>改派 = 负责人变更;改派留痕并通知双方,任务记忆与草稿层不动。</Note>
<div className="g-field">
<em>新负责人</em>
<div className="g-seg">
@@ -1,183 +0,0 @@
/**
* 调用参数表单 —— 按流程包 `callInterface.input`(JSON Schema 2020-12 子集)现生成。
*
* 表单不认业务字段,只认声明:必填由 `required` 决定,控件由 `type` / `enum` 决定。
* 前端这一层只做**填得顺手**,不做裁决 —— 合不合契约由后端 ajv 判,判词原样回显。
* 少填一个必填就把按钮按灰,是为了不让人白跑一趟接口,不是替后端把关。
*/
import type { ReactNode } from 'react';
import { Field } from '@web-shared/gov/primitives.tsx';
/** 控件五型:字符串 / 数值 / 真假 / 枚举 / 复合(对象与数组落 JSON 文本框) */
export type CallFieldKind = 'text' | 'number' | 'bool' | 'enum' | 'json';
export type CallField = {
readonly key: string;
readonly required: boolean;
readonly kind: CallFieldKind;
readonly options: readonly string[];
/** 声明里的人读名与说明(有就用,没有就退回字段名) */
readonly title: string | undefined;
readonly hint: string | undefined;
};
export type CallValues = Readonly<Record<string, string>>;
function asRecord(v: unknown): Record<string, unknown> | undefined {
return typeof v === 'object' && v !== null && !Array.isArray(v) ? (v as Record<string, unknown>) : undefined;
}
function asStrings(v: unknown): string[] {
return Array.isArray(v) ? v.filter((x): x is string => typeof x === 'string') : [];
}
function kindOf(prop: Record<string, unknown>): CallFieldKind {
if (asStrings(prop['enum']).length > 0) return 'enum';
const t = prop['type'];
if (t === 'number' || t === 'integer') return 'number';
if (t === 'boolean') return 'bool';
if (t === 'object' || t === 'array') return 'json';
return 'text';
}
/**
* 声明 → 字段清单。**必填排前面**:properties 的键序来自库里的 jsonb,
* 是存储顺序不是语义顺序,照抄等于把「哪几个非填不可」藏进随机次序里。
*/
export function callFieldsOf(schema: Readonly<Record<string, unknown>> | undefined): CallField[] {
const props = asRecord(schema?.['properties']);
if (props === undefined) return [];
const required = new Set(asStrings(schema?.['required']));
const fields = Object.entries(props).map(([key, raw]) => {
const prop = asRecord(raw) ?? {};
const title = typeof prop['title'] === 'string' ? prop['title'] : undefined;
const desc = typeof prop['description'] === 'string' ? prop['description'] : undefined;
const fmt = typeof prop['format'] === 'string' ? prop['format'] : undefined;
const t = typeof prop['type'] === 'string' ? prop['type'] : 'any';
return {
key,
required: required.has(key),
kind: kindOf(prop),
options: asStrings(prop['enum']),
title,
hint: desc ?? (fmt === undefined ? t : `${t} · ${fmt}`),
};
});
return fields.sort((a, b) =>
a.required === b.required ? a.key.localeCompare(b.key) : a.required ? -1 : 1,
);
}
/** 起单载荷 —— 空的选填字段不发出去,免得把 `""` 当成「填过了」 */
export function buildCallData(
fields: readonly CallField[],
values: CallValues,
): { data: Record<string, unknown>; errors: string[] } {
const data: Record<string, unknown> = {};
const errors: string[] = [];
for (const f of fields) {
const raw = (values[f.key] ?? '').trim();
if (raw === '') {
if (f.required) errors.push(`${f.key} 必填`);
continue;
}
if (f.kind === 'number') {
const n = Number(raw);
if (Number.isNaN(n)) errors.push(`${f.key} 要是数字`);
else data[f.key] = n;
continue;
}
if (f.kind === 'bool') {
data[f.key] = raw === 'true';
continue;
}
if (f.kind === 'json') {
try {
data[f.key] = JSON.parse(raw) as unknown;
} catch {
errors.push(`${f.key} 不是合法 JSON`);
}
continue;
}
data[f.key] = raw;
}
return { data, errors };
}
/** 占位值:按类型各填一份能过契约的样子,让人一键就能跑通一趟再回头改 */
export function placeholderValues(fields: readonly CallField[]): Record<string, string> {
const out: Record<string, string> = {};
for (const f of fields) {
out[f.key] =
f.kind === 'number'
? '0'
: f.kind === 'bool'
? 'false'
: f.kind === 'enum'
? (f.options[0] ?? '')
: f.kind === 'json'
? '{}'
: `${f.key}-占位`;
}
return out;
}
/**
* 一格一字段。必填不靠星号靠**颜色**:整条注记转黄铜(黄铜在这套图纸语言里恒表
* 「生效 / 裁定 / 人」这类要紧事),扫一眼就知道哪几格非填不可。
*/
export function CallForm({
fields,
values,
onChange,
}: {
fields: readonly CallField[];
values: CallValues;
onChange: (key: string, v: string) => void;
}): ReactNode {
return (
<>
{fields.map((f) => {
const v = values[f.key] ?? '';
const hint = `${f.required ? '必填' : '选填'}${f.hint === undefined ? '' : ` · ${f.hint}`}`;
return (
<div key={f.key} className={'g-tb-f' + (f.required ? ' req' : '')}>
<Field k={f.title ?? f.key} hint={hint}>
{f.kind === 'enum' ? (
<select className="g-select" value={v} onChange={(e) => onChange(f.key, e.target.value)}>
<option value="">不填</option>
{f.options.map((o) => (
<option key={o} value={o}>
{o}
</option>
))}
</select>
) : f.kind === 'bool' ? (
<select className="g-select" value={v} onChange={(e) => onChange(f.key, e.target.value)}>
<option value="">不填</option>
<option value="true">是</option>
<option value="false">否</option>
</select>
) : f.kind === 'json' ? (
<textarea
className="g-ta mono"
rows={3}
value={v}
placeholder="{ }"
onChange={(e) => onChange(f.key, e.target.value)}
/>
) : (
<input
className={'g-input' + (f.kind === 'number' ? '' : ' mono')}
type={f.kind === 'number' ? 'number' : 'text'}
value={v}
onChange={(e) => onChange(f.key, e.target.value)}
/>
)}
</Field>
</div>
);
})}
</>
);
}
@@ -13,11 +13,9 @@ import type { ProcessNode, ProcessPackage } from '@contracts';
import { TERMINAL_STATE_LABEL, WORKFLOW_STATE_LABEL, testCurrentRoute, testRunRoute, testStopRoute } from '@contracts';
import { Ico } from '@web-shared/Ico.tsx';
import { call } from '@web-shared/typed-fetch.ts';
import { useGovPackages, useGovStaff } from '@web-shared/gov/gov-api.ts';
import { Acts, Field, Note, PageHead, QueryGate, St } from '@web-shared/gov/primitives.tsx';
import { useGovChannels, useGovPackages, useGovStaff } from '@web-shared/gov/gov-api.ts';
import { Note, PageHead, QueryGate, St } from '@web-shared/gov/primitives.tsx';
import type { Nav } from '@web-shared/gov/gov-route.ts';
import { CallForm, buildCallData, callFieldsOf, placeholderValues } from './call-form.tsx';
import type { CallValues } from './call-form.tsx';
import { isLive, useRunTrace, useRunWorkflow } from './run-api.ts';
import { TraceSheet } from './trace-sheet.tsx';
@@ -33,36 +31,10 @@ const NODE_KIND_LABEL: Readonly<Record<string, string>> = {
end: '终点',
};
function Sheet({
code,
title,
ico,
extra,
tight,
children,
}: {
code: string;
title: string;
ico: string;
extra?: ReactNode;
tight?: boolean;
children: ReactNode;
}): ReactNode {
return (
<div className="g-sheet">
<div className="g-sheet-h">
<Ico name={ico} s={12} />
{code} — {title}
{extra !== undefined && <span className="x">{extra}</span>}
</div>
<div className={'g-sheet-b' + (tight === true ? ' tight' : '')}>{children}</div>
</div>
);
}
export function SimulateRun({ nav }: { nav: Nav }): ReactNode {
const pkgQ = useGovPackages();
const staffQ = useGovStaff();
const chanQ = useGovChannels();
/** 只列有生效版的:同一个包可能存着多版,能起单的只有 `active` 那一版 */
const livePkgs = useMemo<ProcessPackage[]>(
@@ -71,10 +43,10 @@ export function SimulateRun({ nav }: { nav: Nav }): ReactNode {
);
const staff = useMemo(() => (staffQ.data?.staff ?? []).filter((s) => s.state === 'active'), [staffQ.data]);
const staffName = (id: string): string => staff.find((s) => s.id === id)?.name ?? id;
const inbox = (chanQ.data?.channels ?? []).find((ch) => ch.kind === 'mail' && ch.enabled);
const [pickedId, setPicked] = useState('');
const [subject, setSubject] = useState('测试台试跑');
const [values, setValues] = useState<CallValues>({});
const [mail, setMail] = useState<MailDraft>(SAMPLE_MAIL);
const [assignments, setAssignments] = useState<Readonly<Record<string, string>>>({});
const queryClient = useQueryClient();
const [workflowId, setWorkflowId] = useState<string | undefined>(undefined);
@@ -102,19 +74,17 @@ export function SimulateRun({ nav }: { nav: Nav }): ReactNode {
// 没选就落到第一个有生效版的包 —— 常见情形只有一个包,不该逼人先点一下
const pkg = livePkgs.find((p) => p.id === pickedId) ?? livePkgs[0];
const fields = useMemo(() => callFieldsOf(pkg?.callInterface.input), [pkg]);
const nodes = useMemo(() => (pkg?.nodes ?? []).filter(isAssignable), [pkg]);
const built = useMemo(() => buildCallData(fields, values), [fields, values]);
const ready = pkg !== undefined && subject.trim() !== '' && built.errors.length === 0;
const to = mail.to === '' ? (inbox?.address ?? '') : mail.to;
const ready = pkg !== undefined && mail.from.trim() !== '' && to !== '' && mail.subject.trim() !== '';
const run = useMutation({
mutationFn: (body: { packageId: string; subject: string; data: Record<string, unknown>; assignments: Record<string, string> }) =>
call<RunOutput>(testRunRoute, { body }),
mutationFn: (input: RunInput) => call<RunOutput>(testRunRoute, { body: input }),
onSuccess: (r) => {
setWorkflowId(r.workflowId);
setError(undefined);
},
// 后端的判词照抄:「输入不合调用接口契约」「流程包无生效版本」都是要人改配置的话,不该被我改写
// 后端的判词照抄:「抽不出客户码」「无生效版」都是要人改配置的话,不该被我改写
onError: (e: unknown) => setError((e as { message?: string }).message ?? '起单失败'),
});
@@ -122,21 +92,14 @@ export function SimulateRun({ nav }: { nav: Nav }): ReactNode {
if (pkg === undefined) return;
run.mutate({
packageId: pkg.id,
subject: subject.trim(),
data: built.data,
mail: { ...mail, to },
assignments: Object.fromEntries(Object.entries(assignments).filter(([, v]) => v !== '')),
});
};
if (running !== undefined) {
return (
<Observe
id={running}
staffName={staffName}
nav={nav}
stopping={stop.isPending}
onBack={() => stop.mutate(running)}
/>
<Observe id={running} staffName={staffName} nav={nav} stopping={stop.isPending} onBack={() => stop.mutate(running)} />
);
}
@@ -149,7 +112,7 @@ export function SimulateRun({ nav }: { nav: Nav }): ReactNode {
tone="brand"
kicker="联调测试台 · 装配态"
title="仿真试跑"
desc="装一次调用、把流真起起来,然后看穿它怎么跑。任务照旧落到被指派人的工作台 —— 测试台不代答。"
desc="这条流真实的起法就是一封客户来信 —— 写这封信、指派每个节点归谁,起单看穿全程。任务照旧落到被指派人的工作台。"
chips={
<>
<St tone={pkg === undefined ? 'warn' : 'ok'} ico={pkg === undefined ? 'alert-circle' : 'circle-check'}>
@@ -171,160 +134,194 @@ export function SimulateRun({ nav }: { nav: Nav }): ReactNode {
]}
/>
<div className="g-tb">
<QueryGate query={pkgQ}>
{livePkgs.length === 0 ? (
<div className="g-sheet">
<div className="g-tb-empty">
<Ico name="scan" s={26} />
<b>没有可起单的流程包</b>
<p>
试跑要有一个<b>生效版</b>才起得来。去「流程包」里保存一版 —— 存得进去的版本就是生效的。
</p>
</div>
<QueryGate query={pkgQ}>
{livePkgs.length === 0 ? (
<div className="g-rig">
<div className="g-tb-empty">
<Ico name="scan" s={26} />
<b>没有可起单的流程包</b>
<p>
试跑要有一个<b>生效版</b>才起得来。去「流程包」里保存一版 —— 存得进去的版本就是生效的。
</p>
</div>
) : (
<>
{/* 一张装配单读下来就是一次试跑的次序:选包 → 填参 → 派人 → 起单 */}
<div className="g-tb-rig">
<Sheet code="PKG" title="流程包" ico="workflow" extra={`${livePkgs.length} 个生效`}>
<div className="g-tbpkgs">
{livePkgs.map((p) => (
<button
key={p.id}
className={'g-tbpkg' + (p.id === pkg?.id ? ' on' : '')}
onClick={() => {
setPicked(p.id);
setValues({});
setAssignments({});
}}
>
<b>{p.name}</b>
<span className="id">
{p.id}@v{p.version}
</span>
<span className="cnt">
<span>节点 {p.nodes.length}</span>
<span>边 {p.edges.length}</span>
<span>入参 {callFieldsOf(p.callInterface.input).length}</span>
</span>
</button>
))}
</div>
<Note>只列有生效版的包。在途的流按起单时那一版跑完,改包不影响它们。</Note>
</Sheet>
</div>
) : (
/* 左选流,右配置 —— 一屏两大块,不再把装配单摞成一长条 */
<div className="g-rig">
<aside className="g-rig-l">
<div className="g-rig-h">
<Ico name="workflow" s={11} />
流程包
<span className="x">{livePkgs.length}</span>
</div>
<div className="g-rig-pk">
{livePkgs.map((p) => (
<button
key={p.id}
className={'g-pk' + (p.id === pkg?.id ? ' on' : '')}
onClick={() => {
setPicked(p.id);
setAssignments({});
}}
>
<b>{p.name}</b>
<span className="id">
{p.id}@v{p.version}
</span>
<span className="cnt">
<i>节点 {p.nodes.length}</i>
<i>边 {p.edges.length}</i>
</span>
</button>
))}
</div>
</aside>
<Sheet
code="ARG"
title="调用参数"
ico="sliders-horizontal"
extra={pkg === undefined ? '' : `按 ${pkg.id} 的调用接口`}
>
{fields.length === 0 ? (
<Note>这个包的调用接口没声明入参 —— 直接起单即可。</Note>
) : (
<>
<div className="g-tbargs">
<CallForm
fields={fields}
values={values}
onChange={(k, v) => setValues((prev) => ({ ...prev, [k]: v }))}
/>
</div>
<Acts
align="end"
items={[
{ label: '填占位值', ico: 'sparkles', onClick: () => setValues(placeholderValues(fields)) },
{ label: '清空', ico: 'trash-2', onClick: () => setValues({}) },
]}
/>
</>
)}
</Sheet>
<section className="g-rig-r">
<div className="g-rig-h">
<span className="n">01</span>
输入配置
<span className="x">启动这条流的那封信</span>
</div>
<MailForm draft={{ ...mail, to }} onChange={setMail} inbox={inbox?.address} />
<div className="g-rig-h">
<span className="n">02</span>
节点指派
<span className="x">
{pinned}/{nodes.length} 已定 · 留空即照旧轮值
</span>
</div>
<div className="g-asn">
{nodes.map((n) => (
<div key={n.id} className={'g-asn-r' + ((assignments[n.id] ?? '') === '' ? '' : ' pinned')}>
<span className="nid">{n.id}</span>
<span className="kd">{NODE_KIND_LABEL[n.kind] ?? n.kind}</span>
<span className="lb">{n.label}</span>
<select
className="g-select"
value={assignments[n.id] ?? ''}
onChange={(e) => setAssignments((prev) => ({ ...prev, [n.id]: e.target.value }))}
>
<option value="">照旧轮值</option>
{staff.map((s) => (
<option key={s.id} value={s.id}>
{s.name} · {s.position.code}
</option>
))}
</select>
</div>
))}
</div>
<Sheet code="ASN" title="节点指派" ico="user-check" extra={`${nodes.length} 个可指派 · 已定 ${pinned}`}>
{/* 分两栏排:一条流七八个节点,单栏会把这张卡拉得比整块装配单还长 */}
<div className="g-asn-2">
{[nodes.slice(0, Math.ceil(nodes.length / 2)), nodes.slice(Math.ceil(nodes.length / 2))]
.filter((half) => half.length > 0)
.map((half, i) => (
<div key={i} className="g-asn">
<div className="g-asn-h">
<span>节点</span>
<span>类型</span>
<span>名称</span>
<span>派给谁</span>
</div>
{half.map((n) => (
<div key={n.id} className={'g-asn-r' + ((assignments[n.id] ?? '') === '' ? '' : ' pinned')}>
<span className="nid">{n.id}</span>
<span className="kd">{NODE_KIND_LABEL[n.kind] ?? n.kind}</span>
<span className="lb">{n.label}</span>
<select
className="g-select"
value={assignments[n.id] ?? ''}
onChange={(e) => setAssignments((prev) => ({ ...prev, [n.id]: e.target.value }))}
>
<option value="">照旧轮值</option>
{staff.map((s) => (
<option key={s.id} value={s.id}>
{s.name} · {s.position.code}
</option>
))}
</select>
</div>
))}
</div>
))}
</div>
<Note>
留空即<b>照旧轮值</b>(有员工组按组轮,没有按全员最闲者先)。指派只在那个人<b>接得了这个节点</b>
时生效,接不了会退回轮值 —— 实际受理人以 TRACE 里那一行为准。
{error !== undefined && (
<Note tone="warn">
<b>没起成:</b>
{error}
</Note>
</Sheet>
<Sheet code="RUN" title="起单" ico="play" extra={ready ? '装配齐了' : '还差料'}>
<div className="g-tbrun">
<div className="g-tb-f">
<Field k="试跑标题" hint="落在工作流上的题,观测态与运营中心都按它认这一单">
<input className="g-input" value={subject} onChange={(e) => setSubject(e.target.value)} />
</Field>
</div>
<Acts
items={[
{
label: run.isPending ? '起单中…' : '起单试跑',
ico: 'play',
primary: true,
disabled: !ready || run.isPending,
onClick: fire,
},
]}
/>
</div>
{built.errors.length > 0 && (
<Note tone="warn">
<b>还差 {built.errors.length} 项才起得来:</b>
{built.errors.join(' · ')}
</Note>
)}
{error !== undefined && (
<Note tone="warn">
<b>没起成:</b>
{error}
</Note>
)}
</Sheet>
</>
)}
</QueryGate>
</div>
)}
</section>
</div>
)}
</QueryGate>
</>
);
}
/* ── 观测态 ─────────────────────────────────────────────────────────── */
/* ==================== 启动输入:一封信 ==================== */
type MailDraft = {
from: string;
to: string;
subject: string;
body: string;
attachments: ReadonlyArray<{ name: string; contentType: string; size: number }>;
};
type RunInput = { packageId: string; mail: MailDraft; assignments: Record<string, string> };
const XLSX = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
/**
* 预填的是一封**抽得出键**的信 —— 主题里带客户码与询价单号,
* 通道的抽键正则就是照着这两样写的;改坏了起单会如实报「抽不出哪个」。
*/
const SAMPLE_MAIL: MailDraft = {
from: 'buyer@sz-machinery.com',
to: '',
subject: '【询价】C014 / RFQ-2607-001 工控主板 BOM 12 项',
body: '你好,附件是本次询价的 BOM,共 12 项,请按标准交期报价。\n付款方式沿用上次合同。',
attachments: [{ name: 'BOM-RFQ-2607-001.xlsx', contentType: XLSX, size: 28_416 }],
};
function MailForm({
draft,
onChange,
inbox,
}: {
draft: MailDraft;
onChange: (next: MailDraft) => void;
inbox: string | undefined;
}): ReactNode {
const set = <K extends keyof MailDraft>(k: K, v: MailDraft[K]): void => onChange({ ...draft, [k]: v });
return (
<div className="g-ml">
<label className="g-ml-r">
<em>发件人</em>
<input className="g-ml-i" value={draft.from} onChange={(e) => set('from', e.target.value)} />
</label>
<label className="g-ml-r">
<em>收件人</em>
<input
className="g-ml-i"
value={draft.to}
placeholder={inbox ?? '公司询价邮箱'}
onChange={(e) => set('to', e.target.value)}
/>
<span className="g-ml-t">投给哪个信箱决定用哪套抽键规则</span>
</label>
<label className="g-ml-r">
<em>主题</em>
<input className="g-ml-i" value={draft.subject} onChange={(e) => set('subject', e.target.value)} />
<span className="g-ml-t">客户码与询价单号从这里抽</span>
</label>
<label className="g-ml-r tall">
<em>正文</em>
<textarea className="g-ml-i" rows={4} value={draft.body} onChange={(e) => set('body', e.target.value)} />
</label>
<div className="g-ml-r tall">
<em>附件</em>
<div className="g-ml-at">
{draft.attachments.map((a, i) => (
<span key={a.name} className="g-att">
<Ico name="paperclip" s={11} />
{a.name}
<i>{(a.size / 1024).toFixed(0)} KB</i>
<button
aria-label={`移除 ${a.name}`}
onClick={() => set('attachments', draft.attachments.filter((_, j) => j !== i))}
>
<Ico name="x" s={10} />
</button>
</span>
))}
<button
className="g-att-add"
onClick={() =>
set('attachments', [
...draft.attachments,
{ name: `BOM-${draft.attachments.length + 1}.xlsx`, contentType: XLSX, size: 20_480 },
])
}
>
<Ico name="plus" s={11} />
加一个 BOM
</button>
</div>
</div>
</div>
);
}
function Observe({
id,
@@ -33,7 +33,7 @@ import {
St,
} from '@web-shared/gov/primitives.tsx';
import type { Nav } from '@web-shared/gov/gov-route.ts';
import { useGovLlm, useGovTools } from '@web-shared/gov/gov-api.ts';
import { useGovTools } from '@web-shared/gov/gov-api.ts';
export type HomeProps = { tab: string; nav: Nav };
@@ -120,17 +120,11 @@ const LLM_TOOLS = [
export function ToolsHome({ nav }: HomeProps) {
const tools = useGovTools();
const llm = useGovLlm();
const rows = tools.data?.tools ?? [];
return (
<QueryGate query={tools}>
<>
<Note>
一件事能交给谁办,全集在这里:交给<b>系统</b>(功能工具)、交给<b>模型</b>(LLM)、交给
<b>人</b>(人类工具)。工具承载权力,约束严于活动 —— 契约对活动、实现对系统、凭证只存治理台。
</Note>
<Sec ico="wrench" title="功能工具" extra={`${rows.length} 件 · 读类自由调用,写类登记意向、放行后落地`}>
{rows.length === 0 ? (
<Clear>目录里还没有工具 —— 从下面「接入」导入一件,或由第一方随系统装入。</Clear>
@@ -203,12 +197,7 @@ export function ToolsHome({ nav }: HomeProps) {
</div>
))}
</div>
<Note>
已绑 {(llm.data?.instances ?? []).length} 个模型实例:
{(llm.data?.instances ?? []).map((m) => m.name).join(' · ') || '尚未绑定'}。
换厂商或型号去<button className="g-link" onClick={() => nav.jump('models', 'llm')}>大模型</button>改绑定。
</Note>
</Sec>
</Sec>
<Sec ico="hand" title="人类工具" extra="调人也是调工具 · 打扰上限在契约授权边界,由 Harness 强制">
<div className="g-shelf">
@@ -311,11 +300,7 @@ function ImportToolCard() {
</button>
}
>
<Note>
交一份调用契约 + 一个能调通的端点,两审当场跑:静态审读契约,试运行审<b>真调那个端点</b>。
调不通就不入目录 —— 一件调不通的工具进了目录,活动用它时才失败,那才是真的坏。
</Note>
</Card>
</Card>
);
}
@@ -427,11 +412,7 @@ function McpCard() {
</St>
}
>
<Note>
MCP 服务器上的工具,接进来之后与自定义工具同等待遇:经<b>工具调用一缝</b>去调、过两审入目录、
按白名单授给活动。当前系统还没有 MCP 客户端 —— 这里如实标着未连接,不摆一个点不动的按钮。
</Note>
</Card>
</Card>
);
}
@@ -466,7 +447,6 @@ export function ToolPage({ id }: { id: string }) {
<p className="g-desc">{t.description}</p>
</Card>
<Card ico="shield-check" title="连接配置">
<Note>凭证隔离:治理台只回<b>配置键</b>,永不回值;密钥不入包、不入活动、不入留痕明文。</Note>
<div className="g-rows">
{t.connectionKeys.map((k) => (
<div key={k}>
@@ -1,319 +0,0 @@
/**
* 触发器 · 入站邮件演练 —— 从**外界**推一封信进来,看哪条规则接住它。
*
* 摆在触发器区里,是因为它验的正是这一区定的东西:规则写下来了,来一封真信试试对不对。
*
* 造一封入站邮件(可带附件)投进通道,走的是**与真通道同一条**入站归一链路
* (`POST /api/ingest/channel/:id/mail` → 归属解析 → 统一事件流 → 三级消费)。
* 邮件通道是外界,模拟通道是允许的(README:mock 只许出现在外界);
* 系统内部机制这里一行都不 mock —— 命中判定、起单、消息兜底全是真的。
*
* 这一屏要回答的是三个问题,所以结果就摆这三样:
* · 归属判到谁了(哪一级、认领岗位)
* · 谁接了(任务监听 / 触发器,各命中几个)
* · 没人接的话落哪儿(消息兜底)
*/
import { useMemo, useState } from 'react';
import { useMutation } from '@tanstack/react-query';
import type { IngestMailOutput, InboundMail } from '@contracts';
import { ingestMailRoute } from '@contracts';
import { call } from '@web-shared/typed-fetch.ts';
import { useGovChannels, useGovStaff } from '@web-shared/gov/gov-api.ts';
import { Acts, Band, Card, Field, Note, Rows, Sec, St } from '@web-shared/gov/primitives.tsx';
import type { Nav } from '@web-shared/gov/gov-route.ts';
/*
* 出参形状**直接用契约类型**,不手搓。
* 我手搓过一次(`level` / `kind` / `position` / `rationale`),四个字段名全是编的 ——
* 页面上就摆出两个永远显示「—」的格子。归属解析真实是按 `outcome` 判别的联合:
* owned 给 `rule` + `taskId`,unowned 给 `reason` + 可选的 `fallbackPosition`。
*/
type IngestResult = IngestMailOutput;
const RULE_LABEL: Readonly<Record<string, string>> = {
thread: '①线程精确 —— 回信落在原线程上',
'listener-key': '②关联键命中在途任务的监听',
'address-window': '③地址 + 时间窗对上了',
};
const REASON_LABEL: Readonly<Record<string, string>> = {
'no-match': '三级都没对上',
ambiguous: '对上多条,有歧义 —— 宁交人不错投',
'extract-failed': '归属键抽不出来',
};
type Attach = { name: string; contentType: string; size: number; ref: string };
/**
* 样例邮件 —— 一键就能起单的那一封。
*
* 三件事都得对,少一件就不起单(这也正是这一屏要让人看见的):
* ① 投给「公司询价邮箱」这个通道(触发器规则写死了 `channelId = "ch-rfq-mail"`)
* ② 主题含「询价」或 RFQ(触发器规则的第二半)
* ③ 正文或主题里有客户码 `C\d{3}` 与单号 `RFQ-[A-Z0-9]+` —— 通道的归属键提取规则按正则抽,
* 抽不出来就没有关联键,起单装配拿不到 customerCode / rfqRef
*/
const SAMPLE = {
from: 'buyer@sz-precision.com',
to: 'rfq@we.com',
subject: '【询价】RFQ-2607-501 精密车削件 6 项',
body: [
'你好,',
'',
'我方客户码 C014,本次询价单号 RFQ-2607-501,附件是 BOM 清单(6 项)。',
'月需约 2000 套,请两周内回价。',
'',
'深圳精密件采购部',
].join('\n'),
};
const SAMPLE_ATTACH: Attach = {
name: 'BOM-RFQ-2607-501.xlsx',
contentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
size: 18_432,
ref: 'sim://attach/BOM-RFQ-2607-501.xlsx',
};
export function InboundDrill({ nav }: { nav: Nav }) {
const channels = useGovChannels();
const rows = channels.data?.channels ?? [];
// 岗位在出参里是 id;摆一串 UUID 等于没说 —— 换成人读的名字
const staffQ = useGovStaff();
const positionName = (id: string) =>
(staffQ.data?.positions ?? []).find((p) => p.id === id)?.name ?? id;
const [channelId, setChannelId] = useState('');
const [from, setFrom] = useState(SAMPLE.from);
const [to, setTo] = useState(SAMPLE.to);
const [subject, setSubject] = useState(SAMPLE.subject);
const [body, setBody] = useState(SAMPLE.body);
const [attachments, setAttachments] = useState<readonly Attach[]>([SAMPLE_ATTACH]);
const [result, setResult] = useState<IngestResult | undefined>(undefined);
const [error, setError] = useState<string | undefined>(undefined);
// 没选通道时默认落到第一个 —— 让「一键投递」真的一键
const effectiveChannel = channelId !== '' ? channelId : (rows[0]?.id ?? '');
const channel = rows.find((c) => c.id === effectiveChannel);
/**
* 起单前置自检 —— 把「为什么没起单」提前说出来,而不是让人投完了猜。
* 判据与通道/触发器的真实配置同源:通道 id、主题关键词、两个归属键正则。
*/
const preflight = useMemo(() => {
const text = `${subject}\n${body}`;
return [
{ ok: effectiveChannel === 'ch-rfq-mail', k: '投给公司询价邮箱', v: 'ch-rfq-mail' },
{ ok: /询价|RFQ/.test(subject), k: '主题含「询价」或 RFQ', v: '触发器规则' },
{ ok: /\bC\d{3}\b/.test(text), k: '含客户码', v: 'C000 形' },
{ ok: /RFQ-[A-Z0-9]+/.test(text), k: '含询价单号', v: 'RFQ-XXXX 形' },
];
}, [effectiveChannel, subject, body]);
const allGreen = preflight.every((p) => p.ok);
const send = useMutation({
mutationFn: (mail: InboundMail) =>
call<IngestResult>(ingestMailRoute, { params: { channelId: effectiveChannel as never }, body: mail }),
onSuccess: (r) => {
setResult(r);
setError(undefined);
},
onError: (e: unknown) => {
setResult(undefined);
setError((e as { message?: string }).message ?? '投递失败');
},
});
const fire = () => {
// messageId 每次不同 —— 同一封信重投在归属解析里会被当同一线程,那是另一回事
const stamp = Date.now();
send.mutate({
messageId: `sim-${stamp}`,
from,
to: [to],
cc: [],
subject,
body,
receivedAt: new Date().toISOString(),
attachments: [...attachments],
} as InboundMail);
};
return (
<>
<Band ico="flask-conical" extra="定完就地验:规则写下来了,来一封真信试试对不对">
投一封信试试
</Band>
<Note>
走的是与真通道同一条入站链路:通道归一 → 归属解析 → 统一事件流 → 三级消费(任务监听 /
触发器 / 消息兜底)。邮件通道是外界,模拟通道是允许的;命中判定与起单都是真的。
</Note>
<Sec ico="mail" title="造一封信" extra="预填的是一键能起单的样例 —— 改坏了下面的自检会告诉你差哪条">
<Card ico="inbox" title="信头">
{/* `.g-card` 自己不带内距 —— 卡里放自带框的块(Rows / Note)刚好贴边,
放裸表单件就得垫一层卡体;console.css 早备好了 `.g-card-b` */}
<div className="g-card-b">
<Field k="投给哪个通道" hint="触发器的规则里写死了通道 id,投错通道不会命中">
<select className="g-select" value={effectiveChannel} onChange={(e) => setChannelId(e.target.value)}>
{rows.map((c) => (
<option key={c.id} value={c.id}>
{c.name} · {c.address}
</option>
))}
</select>
</Field>
<Field k="发件人">
<input className="g-input" value={from} onChange={(e) => setFrom(e.target.value)} />
</Field>
<Field k="收件地址" {...(channel === undefined ? {} : { hint: `通道地址:${channel.address}` })}>
<input className="g-input" value={to} onChange={(e) => setTo(e.target.value)} />
</Field>
<Field k="主题">
<input className="g-input" value={subject} onChange={(e) => setSubject(e.target.value)} />
</Field>
</div>
</Card>
<Card ico="file-text" title="正文">
<div className="g-card-b">
<textarea className="g-ta" rows={7} value={body} onChange={(e) => setBody(e.target.value)} />
</div>
</Card>
<Card
ico="paperclip"
title="附件"
extra={
<Acts
align="end"
items={[
{
label: '加一个附件',
ico: 'plus',
onClick: () =>
setAttachments((a) => [
...a,
{
name: `附件-${a.length + 1}.pdf`,
contentType: 'application/pdf',
size: 1024,
ref: `sim://attach/${a.length + 1}`,
},
]),
},
]}
/>
}
>
{attachments.length === 0 ? (
<Note>没有附件 —— 这封信也照样能起单(触发器判的是通道与主题,不判附件)。</Note>
) : (
<Rows
items={attachments.map((a) => ({
k: a.name,
v: `${a.contentType.split('.').pop() ?? a.contentType} · ${a.size} B · ${a.ref}`,
mono: true,
}))}
/>
)}
<Note>
附件目前只走<b>登记</b>:名字、类型、大小与存证指针进事件信封,内容不解析 ——
解析 Excel / PDF 是活动的事,活动还没实现。
</Note>
</Card>
<Card ico="list-checks" title="起单前置自检" extra="投之前就知道会不会命中,不用投完了猜">
<Rows
items={preflight.map((p) => ({
k: p.k,
v: (
<St tone={p.ok ? 'ok' : 'warn'} ico={p.ok ? 'circle-check' : 'alert-circle'}>
{p.ok ? '齐' : `缺:${p.v}`}
</St>
),
}))}
/>
</Card>
<Acts
align="end"
items={[
{
label: send.isPending ? '投递中…' : allGreen ? '投递这封信' : `还差 ${preflight.filter((p) => !p.ok).length} 条,仍要投`,
ico: 'send',
primary: true,
disabled: send.isPending || effectiveChannel === '',
onClick: fire,
},
]}
/>
</Sec>
{error !== undefined && (
<Note tone="warn">
<b>投递失败:</b>
{error}
</Note>
)}
{result !== undefined && (
<Sec ico="git-merge" title="这封信的下场" extra="归属判到谁 · 谁接了 · 没人接落哪儿">
<Card ico="fingerprint" title="归属解析" extra="匹配次序确定、逐级短路">
<Rows
items={[
{ k: '事件 id', v: result.eventId, mono: true },
...(result.resolution.outcome === 'owned'
? [
{ k: '判定', v: '有主' },
{ k: '命中哪一级', v: RULE_LABEL[result.resolution.rule] ?? result.resolution.rule },
{ k: '归到任务', v: result.resolution.taskId, mono: true },
]
: [
{ k: '判定', v: '无主' },
{ k: '为什么', v: REASON_LABEL[result.resolution.reason] ?? result.resolution.reason },
...(result.resolution.fallbackPosition === undefined
? []
: [{ k: '默认认领岗位', v: positionName(result.resolution.fallbackPosition) }]),
]),
]}
/>
{result.resolution.outcome === 'unowned' && (
<Note>
无主不是错:新来的询价本来就没有在途任务可归。<b>无主入站不写台账</b>,只入事件流,
由触发器决定要不要起单 —— 下面那格就是它的裁决。
</Note>
)}
</Card>
<Card ico="split" title="三级消费">
<Rows
items={[
{ k: '命中任务监听', v: String(result.listenersHit) },
{ k: '命中触发器', v: String(result.triggersHit) },
{ k: '落消息兜底', v: result.fellBackToMessage ? '是' : '否' },
]}
/>
{result.triggersHit > 0 ? (
<Note tone="ok">
触发器命中 {result.triggersHit} 个 —— 已按调起规则起单。去运营中心 · 任务看在途,
或去工作台看落到谁工位上。
</Note>
) : result.listenersHit > 0 ? (
<Note tone="ok">这封信被在途任务的监听接走了 —— 那一单的完成条件因此满足。</Note>
) : (
<Note tone="warn">
没有任何监听或触发器接它,已落消息兜底 —— 认领岗位的人会在「消息」里看到它。
想起单就回上面看自检差哪条。
</Note>
)}
</Card>
<Acts
items={[
{ label: '去运营中心看在途', ico: 'activity', onClick: () => nav.jump('tasks', 'list') },
{ label: '再投一封', ico: 'rotate-ccw', primary: true, onClick: fire },
]}
/>
</Sec>
)}
</>
);
}
@@ -39,8 +39,8 @@ import {
Seg,
St,
} from '@web-shared/gov/primitives.tsx';
import { Ico } from '@web-shared/Ico.tsx';
import type { Nav } from '@web-shared/gov/gov-route.ts';
import { InboundDrill } from './inbound.tsx';
import { useGovObjects, useGovPackages, useGovTriggers } from '@web-shared/gov/gov-api.ts';
import { domainShort } from '@web-shared/gov/domains.ts';
@@ -88,14 +88,10 @@ export function TriggerRulesHome({ nav }: { nav: Nav }) {
return (
<QueryGate query={q}>
<>
<Note>
调起规则决定<b>什么时候起一单</b>:周期 / 事件 / 登记三类。触发器与流程包平级——不入包结构、
不随包版本,改规则不动任何版本。<b>启停不在这里</b>,那是运营中心的事。
</Note>
{triggers.length === 0 ? (
<Clear>还没有调起规则 —— 配一条,这条流就能被自动或人工调起来。</Clear>
) : (
<NList>
<div className="g-shelf">
{triggers.map((t) =>
editing === t.id ? (
<TriggerForm
@@ -105,37 +101,57 @@ export function TriggerRulesHome({ nav }: { nav: Nav }) {
onCancel={() => setEditing(undefined)}
/>
) : (
<NRow
/*
* 卡而不是行:一条规则要一眼看全「何时起 · 起哪条流 · 开没开」,
* 行只放得下前两样。卡是 div 不是 button —— 卡里还坐着「改规则」那枚真按钮。
*/
<div
key={t.id}
tone={t.enabled ? 'brand' : 'mute'}
ico="zap"
title={t.name}
sub={ruleText(t)}
cols={[
{ k: '类别', v: <Chip tone="brand">{TRIGGER_KIND_LABEL[triggerKindOf(t.spec)]}</Chip> },
{ k: '调起', v: t.processPackageId },
{ k: '装配', v: `${t.mapping.length} 条` },
]}
right={
className={'g-tile t-' + (t.enabled ? 'brand' : 'mute')}
role="button"
tabIndex={0}
onClick={() => nav.push({ k: 'trigger', id: t.id })}
onKeyDown={(e) => {
if (e.key === 'Enter' || e.key === ' ') {
e.preventDefault();
nav.push({ k: 'trigger', id: t.id });
}
}}
>
<span className="g-tile-h">
<span className="g-tile-i">
<Ico name="zap" s={16} />
</span>
<span className="g-tile-t">
<b>{t.name}</b>
<em>{t.processPackageId}</em>
</span>
<Chip tone="brand">{TRIGGER_KIND_LABEL[triggerKindOf(t.spec)]}</Chip>
</span>
<span className="g-tile-d">{ruleText(t)}</span>
<span className="g-tile-m">
<Chip ico="arrow-left-right">装配 {t.mapping.length} 条</Chip>
</span>
<span className="g-tile-f">
<St tone={t.enabled ? 'ok' : 'mute'} ico={t.enabled ? 'circle-check' : 'power'}>
{t.enabled ? '起单中' : '已停用'}
</St>
<button
className="g-btn"
className="g-btn r"
onClick={(e) => {
// 行本身也可点(进详情)—— 按钮要拦住冒泡,否则点「改规则」会跳走
// 卡本身也可点(进详情)—— 按钮要拦住冒泡,否则点「改规则」会跳走
e.stopPropagation();
setEditing(t.id);
}}
>
改规则
</button>
}
onClick={() => nav.push({ k: 'trigger', id: t.id })}
/>
</span>
</div>
),
)}
</NList>
</div>
)}
{/* 定完就地验:来一封真信,看这些规则里哪条接住 */}
<InboundDrill nav={nav} />
</>
</QueryGate>
);
@@ -240,9 +256,6 @@ function TriggerForm({
<Field k="类别" hint="周期 / 事件 / 登记三类">
<Seg value={draft.spec.kind} options={SPEC_KINDS.map((s) => ({ k: s.k, label: s.label }))} onPick={setSpecKind} />
</Field>
{draft.spec.kind === 'registration' && (
<Note>登记型无参:人在工作台按调用接口的 schema 填表提交,即起一单。</Note>
)}
{draft.spec.kind === 'event' && (
<>
<Field k="事件类型">
@@ -422,7 +435,6 @@ export function TriggerOpsTab({ nav }: { nav: Nav }) {
))}
</NList>
)}
<Note>逐条启停在触发器详情页做 —— 开关是治理动作,要走影响确认带,不做列表上的顺手一点。</Note>
{toggle.isError && <Note tone="warn">切换失败,请重试。</Note>}
</>
</QueryGate>