人手改的那一手真正落得下去;界面不撒谎那几处补齐

手改是**兜 AI 的错**的那一手 —— 这一轮把它从「摆在那儿但落不了地」做成真的:

件上就地改
· 保存**按地址收**,不看当下那张卡:载荷从前借道工单的 `blocks[i]` 取列名,
  于是熔断卡(没有 blocks)在屏上时,人补的那一格一个字都送不出去 ——
  而他要补的恰恰是把这一单卡住的那个必填格。授权面改由活动清单的台账声明把关。
· **能增删行**:错不止「这一格填错了」,还有「这一行不该在」与「漏了一行」。
  删挂记号不当场抹掉(看得见、可后悔),且**删要说出来**(`drops`)——
  「没回传就是删了」会把一次不完整的回传变成一次删表。
· **必填没填按不下提交**:与放行门 L1 同一个数同一套算法;闸上摆出差在哪一行哪一格。
· 只写真改了的那几行 —— 改一格却留「修订 4 行」的痕,那句话是假的。

判据与门
· 裁量判据带谓词时**谓词说了算**:「选填缺口已补齐」基座数得出来,
  人填好的目标价它照样判「客户未提供」的毛病由此消掉。
· 验收卡判据**读时现算** —— 人在成果件上补一格,判据跟着变。
· 放行门认「**办完了没有**」不认「有人写过」:从前写个 `false` 就把门推开,
  于是一单没打标就进了放行门。三个数全由基座现数。
· 拒回把「活没干完」说成「数或行对不上」的毛病:判据点名的表一行都没写时直说那一步没办。
  **指向两扇打不开的门,比不指还糟。**

界面不撒谎
· 日志只有三色:负责人绿 · 智能体蓝 · 系统灰(归侧五种是度量的分法,不是给人看的)。
· 验收收口答两件事:落了什么(按**交付物**点名,一份成果的几张表并成一行)、
  往哪儿去(转出哪一口、带过去哪些字段);一个口都没发就直说到此为止。
· 签完到收尾之间那一段有自己的话「字已签下,正在落地」—— 中间态本来就该说出来,只是要说对。
· 消息不再被内部事件刷屏:只有从通道进来的件才谈得上「无人认领」。
· 建客户公司与联系人**一次确认落两行**;联系人编码自增不问人;卡面摆表的人读名。

A1 三案例端到端全 released:全 A 类直通 12 拍 / 客户点名跳一条 10 拍 / 新客户缺必填 14 拍。
五道门禁全绿(971 passed)。

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01JsTDjoHovERXyy6Wmw1ALp
This commit is contained in:
2026-08-02 13:41:44 +08:00
co-authored by Claude Opus 5
parent 94f1c7a4ef
commit 259192f736
228 changed files with 27850 additions and 2847 deletions
@@ -7,46 +7,110 @@
* 「对话流是**一切回环输入的唯一入口**」(OS 4.1);输入侧不参与控制权转交(AM 07)。
* AI 的内容只有两种形态、不允许中间态:
* · 纯文本气泡 —— 结论 / 说明 / 回执
* · 完整表单卡 —— 工单卡 / 验收单 / 决策单 / 补全单 / 评价单
* · 完整表单卡 —— 工单卡 / 验收单 / 决策单 / 补全单 / 录入单 / 评价单
* 六张卡共用一套外壳 `jc-fc`(头 = 图标 + 类型名 + 计数,身 = `jc-fc-b`)——
* 谁自造一套骨架,谁在对话流里就显得是外来的。
* 一条消息 = 署名行(AI · 时间 · 类型章)+ 一或两个**纯**块。
* ⛔ 补全 / 决策卡吐出期间 composer 锁定 —— 先办卡,再说话。
*
* DOM 与类名逐字照搬原型:皮肤是原型的原样,自造类名等于没样式。
*/
import { useEffect, useRef, useState } from 'react';
import type { AiTag, ChatCardReply, ChatMessage, WorkOrder, WorkOrderReply } from '@contracts';
import type { FormField, AiTag, ChatCardReply, ChatMessage, WorkOrder, WorkOrderReply } from '@contracts';
import { EVENT_TYPE_LABEL, isRejection } from '@contracts';
import { Ico } from '@web-shared/Ico.tsx';
import { ChatAvatar } from '@web-shared/ChatAvatar.tsx';
import { atClock } from '@web-shared/at.ts';
/** 类型章:结论 = auto,指导 = exe,判据 = acc(原型 TAG_UI 口径) */
/**
* 类型章:结论 = auto,指导 = exe,判据 = acc(原型 TAG_UI 口径)。
*
* **同一个签,带不带工单说的是两件事**:
* 带工单(`ref`)的那条是「我派了一张卡给你」;不带的是 AI 在**交代进展**。
* 只按签取字的话,一句「三条已归一,缺 1 个交期」会被标成「派了工单」——
* 它一张卡也没派。界面不撒谎:没有卡就不写卡的字(实测踩过,满屏「派了工单」)。
*/
const TAG_UI: Readonly<Record<AiTag, { label: string; cls: string }>> = {
conclusion: { label: '阶段结论', cls: 'auto' },
guidance: { label: '派了工单', cls: 'exe' },
guidance: { label: '派出工单', cls: 'exe' },
criterion: { label: '请你验收', cls: 'acc' },
};
/**
* 交代进展的章 —— 同一批签,不带工单时的说法。
*
* **一律四个字**(2026-07-31 用户定):这一列的每一格只说一件事,
* 字数一致那一列才扫得动。从前这里是「进展」「判据」两个字,
* 跟旁边的「阶段结论」一长一短,像两套词表混着用 —— 事实上它们就是一套。
* 工作日志用的也是这一套词(见 `task-log.ts` 的 `actionOf`)。
*/
const SAY_UI: Readonly<Record<AiTag, { label: string; cls: string }>> = {
conclusion: { label: '阶段结论', cls: 'auto' },
guidance: { label: '交代进展', cls: 'auto' },
criterion: { label: '验收判据', cls: 'acc' },
};
/**
* 系统气泡的章 —— **对话区说人话,契约说类型**。
*
* `EVENT_TYPE_LABEL` 是事件分类学(data / time / human / control),治理面按它分区没错;
* 可直接摆进对话流就成了「数据事件」——「一封邮件触发了这条流程」被标成「数据事件」,
* 人看不出这跟自己有什么关系。归侧词表(`SIDE_ST`)里这一类早就叫**触发事件**了,
* 工作日志用的就是它;两屏说同一件事,得用同一个词。
*/
const SYS_TAG: Readonly<Record<string, string>> = {
data: '触发事件',
time: '时间到点',
// 系统气泡里 `human` 只有一个来源:人办结了执行工单(chat-projection 显式打的),
// 裸「事件到达(human)」那条早在投影里就被滤掉了 —— 所以这里说得死一点
human: '员工办结',
control: '控制事件',
};
/** ISO → HH:MM(署名行只要时分) */
const hm = (iso: string) => iso.slice(11, 16);
const hm = (iso: string): string => atClock(iso);
export type TaskChatProps = {
readonly chat: readonly ChatMessage[];
readonly orders: readonly WorkOrder[];
/** AI 正在回话 —— 请求在途即亮「输入中」 */
readonly thinking: boolean;
/**
* AI 正在办这单(Loop 在自己转)—— 与「在打字」是两种状态:
* 打字是**在回你的话**(三点气泡);办事是**环在推进**(均衡条常驻在场)。
* 状态来自任务投影的 runtime,不是前端猜的。
*/
readonly working?: boolean;
onSay(text: string): void;
onReplyCard(reply: ChatCardReply): void;
onReplyOrder(reply: WorkOrderReply): void;
/** 点卡上的「打开工单」→ 视图区定位到那张工单 */
onLocate(orderId: string): void;
onOpenComms(): void;
/** 人在工作区报告上改过的填报值 —— 验收裁决时一并带走(见 TaskChat 的注释) */
readonly orderValues?: Readonly<Record<string, string>>;
/** 卡上填的值也进同一个缓冲 —— 执行单的表单如今长在对话区的卡上 */
onField(key: string, value: string): void;
};
export function ChatStream({ chat, orders, thinking, onSay, onReplyCard, onReplyOrder, onLocate }: TaskChatProps) {
export function ChatStream({
chat,
orders,
thinking,
working = false,
onSay,
onReplyCard,
onReplyOrder,
onLocate,
onOpenComms,
orderValues,
onField,
}: TaskChatProps) {
const [text, setText] = useState('');
const boxRef = useRef<HTMLDivElement>(null);
useEffect(() => {
boxRef.current?.scrollTo({ top: 1e9, behavior: 'smooth' });
}, [chat.length, thinking]);
}, [chat.length, thinking, working]);
// ⛔ 补全 / 决策卡未办结期间不能对话 —— 锁的是**卡**,不是工单
const blocked = chat.some(
@@ -80,9 +144,12 @@ export function ChatStream({ chat, orders, thinking, onSay, onReplyCard, onReply
onReplyCard={onReplyCard}
onReplyOrder={onReplyOrder}
onLocate={onLocate}
onOpenComms={onOpenComms}
onField={onField}
{...(orderValues === undefined ? {} : { orderValues })}
/>
))}
{thinking && (
{thinking ? (
<article className="jc-ag">
<ChatAvatar who="ai" />
<div className="jc-ag-col">
@@ -94,7 +161,9 @@ export function ChatStream({ chat, orders, thinking, onSay, onReplyCard, onReply
</span>
</div>
</article>
)}
) : working ? (
<WorkingStrip />
) : null}
</div>
<div className="copilot-composer session-composer">
@@ -126,9 +195,51 @@ export function ChatStream({ chat, orders, thinking, onSay, onReplyCard, onReply
);
}
/**
* AI 办事条 —— 消息流末尾的**常驻在场**:环在自己转(写台账 / 调工具 / 判局面)。
* 均衡条不是打字点:打字说「正在回你」,均衡条说「正在办事」。
* 头像加呼吸环:第二信号,很轻 —— 只有留意的人看得见。
*
* 导出是给**起手那一刻**用的(`TaskChat` 的空流分支):一单刚起、还没有任何消息时,
* 摆的就该是这一条,而不是一张空态插画 —— 两者形状不同,第一句话到了版式会跳。
*/
export function WorkingStrip() {
return (
<article className="jc-ag" aria-live="polite">
<span className="jc-ava-live" style={{ display: 'inline-flex', borderRadius: 999 }}>
<ChatAvatar who="ai" />
</span>
<div className="jc-ag-col">
<div className="jc-msg-meta">AI · 正在办这单</div>
<span className="jc-aiwork">
<span className="jc-aiwork-eq" aria-hidden>
<i />
<i />
<i />
<i />
</span>
<b className="jc-aiwork-txt">持续推进中</b>
<em className="jc-aiwork-sub">有新进展会随时在这里说</em>
</span>
</div>
</article>
);
}
/* ── Agent 侧包装:头像 + (署名行 → 内容流) ── */
function Ag({ meta, tag, children }: { meta: string; tag?: AiTag | undefined; children: React.ReactNode }) {
const t = tag === undefined ? undefined : TAG_UI[tag];
function Ag({
meta,
tag,
hasOrder = false,
children,
}: {
meta: string;
tag?: AiTag | undefined;
/** 这条消息带不带工单 —— 带才用卡的说法(见 TAG_UI 的注释) */
hasOrder?: boolean;
children: React.ReactNode;
}) {
const t = tag === undefined ? undefined : (hasOrder ? TAG_UI : SAY_UI)[tag];
return (
<article className="jc-ag">
<ChatAvatar who="ai" />
@@ -149,12 +260,19 @@ function Msg({
onReplyCard,
onReplyOrder,
onLocate,
onOpenComms,
orderValues,
onField,
}: {
m: ChatMessage;
orders: readonly WorkOrder[];
onReplyCard: (reply: ChatCardReply) => void;
onReplyOrder: (reply: WorkOrderReply) => void;
onLocate: (orderId: string) => void;
onOpenComms: () => void;
/** 人在工作区报告上改过的值 —— 验收裁决时一并带走 */
orderValues?: Readonly<Record<string, string>> | undefined;
onField: (key: string, value: string) => void;
}) {
// 人的消息:右侧品牌气泡(纯文本)
if (m.k === 'human') {
@@ -181,10 +299,20 @@ function Msg({
<div className="jc-ag-col">
<div className="jc-msg-meta">
系统 · {hm(m.at)}
<b className="jc-mtag m-sys">{EVENT_TYPE_LABEL[m.type]}事件</b>
<b className="jc-mtag m-sys">{SYS_TAG[m.type] ?? `${EVENT_TYPE_LABEL[m.type]}事件`}</b>
</div>
<div className="jc-ag-b sys">
<p className="jc-content">{m.text}</p>
{/*
起单开场白带的那一下 —— 原件在沟通记录里。
**点不点都不挡路**:这条消息之后 AI 照常开跑,不等人按。
*/}
{m.openComms === true && (
<button type="button" className="jc-sys-act" onClick={onOpenComms}>
<Ico name="mail" s={12} />
查看邮件
</button>
)}
</div>
</div>
</article>
@@ -196,12 +324,26 @@ function Msg({
const order = m.ref === undefined ? undefined : orders.find((o) => o.id === m.ref);
const settled = order?.done !== undefined;
return (
<Ag meta={`AI · ${hm(m.at)}`} tag={m.tag}>
<Ag meta={`AI · ${hm(m.at)}`} tag={m.tag} hasOrder={order !== undefined}>
<div className={'jc-ag-b' + (order === undefined ? '' : ' card')}>
<p className="jc-content">{m.text}</p>
{order !== undefined &&
(order.mode === 'acceptance' && m.tag === 'criterion' && !settled ? (
<AcceptForm order={order} onReplyOrder={onReplyOrder} onLocate={onLocate} />
<AcceptForm
order={order}
onReplyOrder={onReplyOrder}
onLocate={onLocate}
{...(orderValues === undefined ? {} : { orderValues })}
/>
) : order.mode === 'execution' && !settled ? (
/* 没办结的执行单 = 一张能就地办的卡:指导书 + 依据 + 表单 + 提交 */
<ExecForm
order={order}
onReplyOrder={onReplyOrder}
onLocate={onLocate}
onField={onField}
{...(orderValues === undefined ? {} : { orderValues })}
/>
) : (
<WoCard order={order} onLocate={onLocate} />
))}
@@ -291,6 +433,36 @@ function Msg({
);
}
/*
* 数据录入卡 —— **确认那一下就是写入**(第五类人类工具)。
* 与补全卡长得像,分量完全不同:补全卡收的是「答案」,AI 拿去再写;
* 这一张收的是「这一行数据」,按下确认基座当场落进台账草稿层,AI 不经手。
* 所以卡面上要**明写落到哪张表** —— 人得知道自己这一下写的是什么。
*/
if (m.k === 'entry') {
const written = m.done !== undefined;
return (
<Ag meta={`AI · ${hm(m.at)}`}>
<div className="jc-ag-b card">
<p className="jc-content">{m.ask}</p>
{/* 外壳与补全/决策/评价同一套 `jc-fc` —— 卡族要长得像一家人,
各自的身份写在头上(图标 + 类型名),不靠各造一套框来区分 */}
<div className="jc-fc t-entry">
<div className="jc-fc-h">
<Ico name="table" s={13} />
<b>数据录入</b>
<em className={written ? 'ok' : ''}>{written ? '已写入' : `${m.fields.length} 项`}</em>
</div>
<div className="jc-fc-b">
{m.basis !== undefined && m.basis.length > 0 && <Kv items={m.basis} />}
<EntryCard card={m} onDone={(values) => onReplyCard({ k: 'entry', cardId: m.id, values })} />
</div>
</div>
</div>
</Ag>
);
}
// 决策:问题文字在上,选择卡嵌在同一气泡里
const chosenLabel =
m.chosen === undefined
@@ -382,7 +554,7 @@ function Kv({ items }: { items: ReadonlyArray<{ k: string; v: string }> }) {
);
}
/* 工单卡:题头 + 单体 + 打开动作 —— 派单 / 已裁决的验收都用它 */
/* 工单卡:题头 + 单体 + 打开动作 —— 已办结的、以及没有作业指导书的都用它 */
function WoCard({ order, onLocate }: { order: WorkOrder; onLocate: (id: string) => void }) {
const result = order.done?.result;
const bad = result !== undefined && isRejection(result);
@@ -398,10 +570,290 @@ function WoCard({ order, onLocate }: { order: WorkOrder; onLocate: (id: string)
</div>
<div className="jc-fc-b">
<p className="jc-fc-q strong">{order.title}</p>
{/*
* **签完之后换一屏**(2026-08-02 用户:「完成验收后反而要把落地结果展示出来」)。
*
* 放行卡上摆的是签字前要核的东西(判据);签完之后人关心的是另一件事 ——
* 这一签下去,世界上发生了什么:落了几行、进了哪几张表、转去哪儿了。
* 那一摞对勾说的还是签之前的话,回看时它答不了这个问题。
* (落地事实取不到的老单仍退回判据表:宁可摆旧的,也不摆空的。)
*/}
{order.mode === 'acceptance' &&
(order.landing !== undefined ? (
<Landing landing={order.landing} />
) : (
order.criteria.length > 0 && <Crit list={order.criteria} />
))}
</div>
<div className="jc-fc-ft">
<button className="jc-btn jc-btn-ghost jc-fc-open" onClick={() => onLocate(order.id)}>
<Ico name="panel-left-open" s={13} /> 打开工单 <Ico name="arrow-right" s={12} />
<Ico name="panel-left-open" s={13} /> 打开报告 <Ico name="arrow-right" s={12} />
</button>
</div>
</div>
);
}
/**
* 判据逐条 —— 验收卡与办结卡同一份。
*
* **「裁了但办不到」不是「未达标」**(2026-08-01 用户当场指出:那条 L4 的红叉「为啥还在」)。
* 裁量项(L3/L4)有三态,卡上要分得出来:
* · 裁成满足 → 达标(绿);
* · **裁成不满足 → 「AI 判为不满足」**(琥珀)+ 理由 —— 它不是活没干完,
* 是 AI 办过、办不到,**把判断交给你**;提交门本来就允许这样提交(裁过即可)。
* · 没裁过 → 未达标(红)—— 那才是活没干完。
* 从前三态挤成两态,人看到一条永远不绿的红叉,既不知道 AI 有没有办过、也不知道为什么,
* 只能凭感觉签 —— 而理由那一句正是他要看的东西。
*/
function Crit({
list,
}: {
list: ReadonlyArray<{ label: string; level: string; pass: boolean; settled?: boolean | undefined; rationale?: string | undefined }>;
}) {
return (
<ul className="jc-rp-crit sm">
{list.map((c, i) => {
// 裁量项:settled 有值才是它。裁过而未满足 = 交给人定,不是缺口
const judged = c.settled === true && !c.pass;
return (
<li key={i} className={c.pass ? 'ok' : judged ? 'judged' : 'no'}>
<span className={'jc-lv jc-lv-' + c.level}>{c.level}</span>
<span className="t">
{c.label}
{judged && c.rationale !== undefined && <em className="jc-crit-why">{c.rationale}</em>}
</span>
<span className="r">
<Ico name={c.pass ? 'circle-check' : judged ? 'circle-alert' : 'circle-x'} s={12} />
{c.pass ? '达标' : judged ? 'AI 判为不满足 · 交你定' : '未达标'}
</span>
</li>
);
})}
</ul>
);
}
/**
* 落地结果 —— **办结之后那一屏**:这一签下去,世界上发生了什么。
*
* 三件事,一件也不多:进了哪几张表各几行、转去哪儿了、试跑挡下了几行。
* 摆的都是放行那一刻的结构化留痕,不转述、不估算 ——
* 「合并 9 行」而其中两行没进表的话,那句话就是假的,所以试跑那一行必须说。
*/
function Landing({
landing,
}: {
landing: NonNullable<Extract<WorkOrder, { mode: 'acceptance' }>['landing']>;
}) {
return (
<div className="jc-landing">
<p className="jc-landing-h">
<Ico name="circle-check" s={13} />
<b>已落地</b>
<span>{landing.rows} 行进正式表</span>
</p>
{landing.tables.length > 0 && (
<ul className="jc-rp-crit sm jc-guide">
{landing.tables.map((t, i) => (
<li key={i}>
<span className="jc-lv jc-lv-done">
<Ico name="file-spreadsheet" s={11} />
</span>
<span className="t">{t.label}</span>
<span className="r">{t.rows} 行</span>
</li>
))}
</ul>
)}
{/*
* **收口要答两件事**(2026-08-02 用户定):落了什么、往哪儿去。
* 往哪儿去分两种:转给下一个活动(带了哪些字段一并说清),
* 或者一个口都没发 —— 那就是这条流到此为止,得说出来,别让人自己猜。
*/}
{landing.ports.length > 0 ? (
<p className="jc-landing-p">
<Ico name="git-branch" s={12} />
<span>
<b>转出</b>
{landing.ports.join(' · ')}
{landing.carried.length > 0 && (
<em className="jc-landing-carry">带过去:{landing.carried.slice(0, 12).join('、')}
{landing.carried.length > 12 ? ` 等 ${landing.carried.length} 项` : ''}
</em>
)}
</span>
</p>
) : (
<p className="jc-landing-p">
<Ico name="circle-check" s={12} />
<span>
<b>到此为止</b>
没有下游出口 —— 这条流走完了
</span>
</p>
)}
{landing.simulated > 0 && (
/* 界面不撒谎:试跑挡下的那几行没进表,不说就等于报了一个假数 */
<p className="jc-landing-p warn">
<Ico name="alert-triangle" s={12} />
<span>试跑:另有 {landing.simulated} 行主数据只留在活动缓存,未落正式表</span>
</p>
)}
</div>
);
}
/**
* 作业指导书 —— **与验收判据同一套版面**(2026-08-02 用户定)。
*
* 「这一单要你做什么」与「做成什么算数」是同一类东西:一条一行、左边一枚章、
* 右边一句结论。判据那一摞已经是这个样子,指导书从前却是一串松散的圆点 ——
* 同一张卡上两套版面语言,人得在两种读法之间来回切。
*
* 与判据的差别只有一处:**指导书没有「达标 / 未达标」** —— 它是要办的事,
* 不是已办成的事。右边那一格只留给最后那条「算做完的标准」:
* 它是这几步的收口,摆在末行才读得顺。**不给步骤画对勾** ——
* 系统并不知道人做没做,画上去就是撒谎。
*/
function Guide({ steps, standard }: { steps?: readonly string[] | undefined; standard?: string | undefined }) {
const list = steps ?? [];
if (list.length === 0 && standard === undefined) return null;
return (
<ul className="jc-rp-crit sm jc-guide">
{list.map((x, i) => (
<li key={i}>
<span className="jc-lv jc-lv-step">{i + 1}</span>
<span className="t">{x}</span>
</li>
))}
{standard !== undefined && (
<li className="done">
<span className="jc-lv jc-lv-done">
<Ico name="target" s={11} />
</span>
<span className="t">
<b>算做完的标准</b>
{standard}
</span>
</li>
)}
</ul>
);
}
/**
* 执行工单卡 —— **作业指导书 + 依据 + 填报表单 + 提交,全在对话区**(2026-08-01 用户定)。
*
* 从前这三样都长在工作区的工单报告里,而那份报告又把活动推的那一屏包在自己里面 ——
* 于是人看到的是「一份报告里嵌着另一份报告」。用户原话:
* 「你用你自己的报告格式嵌套了一层我要的报告格式」。
* 现在分开:**工作区只放件本身**(那份 HTML 模版,可就地改),
* 判据与指导书跟着「要你办的这件事」走,落在对话区的卡上。
*
* 表格那一份值不在这儿收 —— 人是在工作区的件上改的,由外层缓冲带过来
* (与验收裁决同一条路子:编辑与提交分在两个区,缓冲得由壳层持有)。
*/
function ExecForm({
order,
onReplyOrder,
onLocate,
orderValues,
onField,
}: {
order: Extract<WorkOrder, { mode: 'execution' }>;
onReplyOrder: (reply: WorkOrderReply) => void;
onLocate: (id: string) => void;
orderValues?: Readonly<Record<string, string>> | undefined;
onField: (key: string, value: string) => void;
}) {
const val = (f: FormField) => orderValues?.[f.key] ?? f.ai ?? '';
/*
* **必填还空着就按不下提交**(2026-08-02 用户定)——两处必填,一个门:
* · 卡上那几格表单字段(`fields[].required`);
* · 件上那张表里的必填列(`gate`,由基座按台账声明现算,与放行门的 L1 同源)。
*
* 从前只看前者:件上那张表压根不在这道门里,于是一条料缺着年用量也能交回来 ——
* 这一单一路走到放行门才被 L1 拦住,模型连拒五拍熔断(实测)。
* 同一件事在提交那一刻拦下便宜得多:那时缺的是哪一格就摆在他眼前。
* 算不出来(卡上没绑表)就没有 `gate`,按钮照常能按 —— 没有依据的时候不拦人。
*/
const gate = order.gate;
const ok = order.fields.every((f) => f.required !== true || val(f).trim() !== '') && gate?.ready !== false;
return (
<div className="jc-fc t-exe">
<div className="jc-fc-h">
<Ico name="clipboard-check" s={13} />
<b>工单 · 执行</b>
{order.steps !== undefined && order.steps.length > 0 && <em>{order.steps.length} 步</em>}
</div>
<div className="jc-fc-b">
<p className="jc-fc-q strong">{order.title}</p>
{/* 件在工作区 —— 这一钮就是去看它、去改它的门 */}
{/*
* 与验收卡那一钮**同一个形状**(2026-08-02 用户:「格式不统一」)——
* 图标一格、四字粗体一行、小字说明一行、右侧一枚箭头。
* 两张卡是同一族的东西,长成两个样子只会让人多认一次。
*/}
<button className="jc-fc-doc" onClick={() => onLocate(order.id)}>
<span className="jc-fc-doc-ico">
<Ico name="file-text" s={15} />
</span>
<span className="jc-fc-doc-bd">
<b>执行工单</b>
<em>整份清单在工作区,每一格都能就地改;改完回这里提交</em>
</span>
<Ico name="chevron-right" s={14} />
</button>
<p className="jc-fc-q">{order.ask}</p>
<Guide steps={order.steps} standard={order.standard} />
{order.basis.length > 0 && <Kv items={order.basis} />}
{order.fields.map((f) => (
<label key={f.key} className="jc-fc-fld">
<span>
{f.label}
{f.required === true && <em className="jc-req">必填</em>}
</span>
<textarea
className="jc-ta"
rows={2}
placeholder={f.placeholder ?? '写一句就行'}
value={val(f)}
onChange={(e) => onField(f.key, e.target.value)}
/>
</label>
))}
</div>
{gate !== undefined && !gate.ready && (
/* 拦住就得说清差在哪 —— 只有一个灰按钮的话,人只能猜自己哪儿做错了 */
<div className="jc-fc-gate">
<p>
<Ico name="alert-triangle" s={13} />
<b>{gate.why}</b>
</p>
{gate.blanks.length > 0 && (
<ul>
{gate.blanks.slice(0, 8).map((x, i) => (
<li key={i}>{x}</li>
))}
{gate.blanks.length > 8 && <li className="more">还有 {gate.blanks.length - 8} 条</li>}
</ul>
)}
</div>
)}
<div className="jc-fc-ft">
<button
className="jc-btn jc-fc-go"
disabled={!ok}
onClick={() =>
onReplyOrder({
mode: 'execution',
workOrderId: order.id,
values: { ...orderValues },
})
}
>
<Ico name="check" s={13} /> {order.submitLabel ?? '提交'}
</button>
</div>
</div>
@@ -413,10 +865,20 @@ function AcceptForm({
order,
onReplyOrder,
onLocate,
orderValues,
}: {
order: Extract<WorkOrder, { mode: 'acceptance' }>;
onReplyOrder: (reply: WorkOrderReply) => void;
onLocate: (id: string) => void;
/**
* 人在工作区报告上改过的填报值 —— **裁决时一并带走**。
*
* 报告是「AI 已填好、可编辑」,裁决在这儿:两半分在两个区里做。
* 不带过来,回传的 `values` 就恒空 —— 人改了报告,落地时用的还是 AI 的原值
* (第 12 章③ 的一半:人工修订永远落不下来)。
* 一个字没改就是空的 —— 空 = 全盘采信 AI 拟值,契约本来就这么定的。
*/
orderValues?: Readonly<Record<string, string>> | undefined;
}) {
const [why, setWhy] = useState('');
/** 选择组:恰选一口,选口即裁分支 —— 没选之前「通过」不亮 */
@@ -439,23 +901,14 @@ function AcceptForm({
<Ico name="file-text" s={15} />
</span>
<span className="jc-fc-doc-bd">
<em>成果报告 · 视图区可读可编辑</em>
<b>{order.title}</b>
{/* 四字粗体在上、说明在下 —— 与执行卡同序,人扫两张卡时落点一致 */}
<b>验收工单</b>
<em>{order.title} · 成果报告在工作区,可读可就地改</em>
</span>
<Ico name="chevron-right" s={14} />
</button>
<ul className="jc-rp-crit sm">
{order.criteria.map((c, i) => (
<li key={i} className={c.pass ? 'ok' : 'no'}>
<span className={'jc-lv jc-lv-' + c.level}>{c.level}</span>
<span className="t">{c.label}</span>
<span className="r">
<Ico name={c.pass ? 'circle-check' : 'circle-x'} s={13} />
{c.pass ? '达标' : '未达标'}
</span>
</li>
))}
</ul>
{/* 与办结卡同一份 —— 两处各写一遍,三态迟早只在一处生效 */}
<Crit list={order.criteria} />
{order.actions !== undefined && order.actions.length > 0 && (
<Kv
items={order.actions.map((a) => ({
@@ -464,6 +917,34 @@ function AcceptForm({
}))}
/>
)}
{/*
* **算出来的去向:只告诉他,不给他选**(2026-08-01)。
*
* 这一单往哪走是分类表那几个数的函数(有没有 C 类、有没有 B 类),
* 契约给每个出口写了判据、基座按序求值定下 —— 摆成选择题,
* 等于把一个可回放的判定换成一次不可回放的手感。
* 但**必须让他看见**:凭哪一条走的这一口,他要能回核。
*/}
{order.routedPort !== undefined && (
/*
* **卡上不摆口名与判据表达式**(2026-08-02 用户指出:卡片上还有
* 「凭 quote_intake_record_type_tag_c > 0」)。
*
* `to-alternative` 与那一串谓词都是给排障看的内部名;签字的人要知道的是
* **「这一单转到哪儿去、凭什么」**,而「凭什么」的人话答案是那一口自己的说明
* (「有 C 类要替代 —— 去选型」),不是它的表达式。
* 报告那一侧已经这么改了,卡这一侧漏了 —— 同一件事两处呈现,口径得一致。
*/
<div className="jc-ports routed">
<p className="jc-ports-t">
这一单的去向 <em>已按料号分类算出 —— 不用选,改分类它就跟着变</em>
</p>
<div className="jc-port on">
<span className="jc-port-dot" />
<b>{order.routedPort.label ?? order.routedPort.name}</b>
</div>
</div>
)}
{choice !== undefined && (
<div className="jc-ports">
<p className="jc-ports-t">
@@ -498,7 +979,8 @@ function AcceptForm({
mode: 'acceptance',
workOrderId: order.id,
verdict: 'redo',
values: {},
// 驳回也把改过的值带上:人常常一边改一边发现问题,改的痕不该丢
values: { ...(orderValues ?? {}) },
comment: why.trim(),
selectedPorts: {},
})
@@ -516,9 +998,25 @@ function AcceptForm({
mode: 'acceptance',
workOrderId: order.id,
verdict: 'pass',
values: {},
// 恰选一口:选中的口随放行一并确认 —— 它就是这次运行的 outcome
selectedPorts: choice === undefined || port === undefined ? {} : { [choice.group]: port },
// 人在报告上改过的值随放行落地;一个字没改就是空的(= 全盘采信 AI 拟值)
values: { ...(orderValues ?? {}) },
/*
* 恰选一口 —— **算出来的那一口也要交回去**。
*
* 两条来路:能算就算(`routedPort`,基座按出口谓词求值)、算不出才让人选
* (`portChoice`)。从前这里只认后者:去向算出来的那一路 `selectedPorts`
* 恒空,人按下「确认通过」→ 放行落地当场判「选择组未选出口」→ 整单 blocked
* (实测:台账都合并进正式表了,单子却死在最后一步)。
* 试跑脚本一直自己带着 port,所以这条只在真人点的那条路上现形。
*
* 人按下的是「确认」:确认的正是基座算出来的那一口。
*/
selectedPorts:
order.routedPort !== undefined
? { [order.routedPort.group]: order.routedPort.name }
: choice === undefined || port === undefined
? {}
: { [choice.group]: port },
})
}
>
@@ -561,11 +1059,18 @@ function FillForm({
onDone,
onCant,
}: {
fields: ReadonlyArray<{ key: string; label: string; placeholder?: string | undefined }>;
fields: ReadonlyArray<{ key: string; label: string; placeholder?: string | undefined; value?: string | undefined }>;
onDone: (values: Record<string, string>) => void;
onCant: (reason: string) => void;
}) {
const [vals, setVals] = useState<Record<string, string>>({});
/*
* **以预填值开局** —— AI 从来件里读得出的(公司名、联系人姓名)已经填在格子里,
* 人核对一眼、补上它填不出的那个即可。
* 用惰性初值而不是 `useEffect` 回填:回填会在人已经开始打字之后把他敲的字冲掉。
*/
const [vals, setVals] = useState<Record<string, string>>(() =>
Object.fromEntries(fields.filter((f) => (f.value ?? '') !== '').map((f) => [f.key, f.value ?? ''])),
);
const [cant, setCant] = useState(false);
const [reason, setReason] = useState('');
const ok = fields.every((f) => (vals[f.key] ?? '').trim() !== '');
@@ -666,3 +1171,130 @@ function RateForm({ onDone }: { onDone: (score: number, note: string) => void })
</div>
);
}
/**
* 数据录入卡的表单 —— AI 预填、人可改、必填空着不让确认。
*
* 与补全卡的 `FillForm` 分开写而不是加个开关:两者的**语义**不同 ——
* 那边按「确认」是交答案,这边按下去是**往台账写一行**。
* 按钮上的字、落表的提示、必填的拦法都得说这件事,合成一个组件只会让两边都含糊。
*/
function EntryCard({
card,
onDone,
}: {
card: Extract<ChatMessage, { k: 'entry' }>;
onDone: (values: Record<string, string>) => void;
}) {
/*
* **一张卡可以落好几张表**(2026-08-02 用户:「新建客户 联系人和公司都需要确认」)。
* 建一位新客户落的是两条主数据:公司档 + 联系人档。从前卡上只有公司那一半,
* 联系人由 AI 自己写 —— 而联系人档的 `contact_code` 是它编出来的,人一眼没看过。
* 值按段隔开(`段号.列名`):两张表都有 `name` 这一列,平铺就会互相盖掉。
*/
const groups = [
{
title: '',
ledger: card.ledger,
...(card.ledgerLabel === undefined ? {} : { ledgerLabel: card.ledgerLabel }),
key: card.key,
...(card.keyLabels === undefined ? {} : { keyLabels: card.keyLabels }),
fields: card.fields,
...(card.autoNote === undefined ? {} : { autoNote: card.autoNote }),
},
...(card.also ?? []),
];
const at = (i: number, key: string) => `${i}.${key}`;
/* 以 AI 预填值开局 —— 惰性初值,不用 effect 回填(那会冲掉人已经敲的字) */
const [vals, setVals] = useState<Record<string, string>>(() =>
Object.fromEntries(groups.flatMap((g, i) => g.fields.map((f) => [at(i, f.key), f.value ?? '']))),
);
const done = card.done !== undefined;
const shown = (i: number, key: string) =>
done ? (card.done?.values[at(i, key)] ?? card.done?.values[key] ?? '') : (vals[at(i, key)] ?? '');
const blank = groups.flatMap((g, i) => g.fields.filter((f) => f.required && shown(i, f.key).trim() === ''));
/*
* **落表那一句合成一条**(2026-08-02 用户:「多个合并成一个:已写入 xxx、xxx」)。
*
* 从前每一段各摆一条「确认后写入 · 客户档案」——两段就是两条横幅,说的是同一件事
* (这一下确认会落库),只是落的表不同。人要知道的是「会写到哪几张表」,
* 那是一句话:**确认后写入 客户档案、客户联系人**。
*/
const tables = groups.map((g) => g.ledgerLabel ?? g.ledger).join('、');
/*
* **主键行只摆整张卡都填不到的那几格**(2026-08-02)。
*
* 从前按段算:联系人那段的表单里没有客户编码,于是它被当成「上游定死的」摆了出来 ——
* 可人正要在**上一段**亲手填它。同一个值在一张卡上出现两次,后一次还是旁白。
* 现在跨段看:任何一段的表单里有,就不摆;一格不剩就整行不出。
*/
const onAnyForm = new Set(groups.flatMap((g) => g.fields.map((f) => f.key)));
const fixed = groups
.flatMap((g, i) =>
Object.entries(g.key)
.filter(([k, v]) => !onAnyForm.has(k) && (shown(i, k) || v) !== '')
.map(([k, v]) => `${g.keyLabels?.[k] ?? k} ${shown(i, k) || v}`),
)
.filter((x, i, all) => all.indexOf(x) === i);
return (
<>
{/* 落表提示用公用的 `jc-fc-note` —— 它自带本卡色调,不必自造一条横幅 */}
<p className="jc-fc-note">
<Ico name="database" s={13} />
<span>
<b>{done ? '已写入' : '确认后写入'}</b>
{/* 摆的是登记的人读名(「客户档案」);没登记人读名才退回地址 —— 界面不摆英文表名 */}
<span className="jc-entry-tbl">{tables}</span>
{fixed.length > 0 && <em className="jc-entry-key">{fixed.join(' · ')}</em>}
</span>
</p>
{groups.map((g, i) => {
return (
<div key={i}>
{/* 两段以上才需要小标题 —— 一段的卡上摆「客户档案」是把上面那句又说了一遍 */}
{g.title !== '' && <p className="jc-entry-sec">{g.title}</p>}
{g.autoNote !== undefined && (
/* 自增的那几列压根不在表单里 —— 但不能一声不吭地拿掉,人会以为这张档少了一格 */
<p className="jc-entry-auto">
<Ico name="circle-dot" s={12} />
{g.autoNote}
</p>
)}
<div className="jc-cfill">
{g.fields.map((f) => {
const v = shown(i, f.key);
const todo = !done && v.trim() === '';
return (
<label key={f.key} className={'jc-cfill-f' + (todo ? ' todo' : '')}>
<span>
{f.label}
{f.required && <i className="req">*</i>}
{/* 空着的明标「待填写」—— AI 填不出来的那几格,人一眼看得见 */}
{todo && <em className="jc-entry-todo">待填写</em>}
</span>
<input
value={v}
disabled={done}
placeholder={f.placeholder ?? (f.required ? '必填' : '可留空')}
onChange={(e) => setVals({ ...vals, [at(i, f.key)]: e.target.value })}
/>
</label>
);
})}
</div>
</div>
);
})}
{!done && (
<div className="jc-cfill-acts">
{blank.length > 0 && <span className="jc-entry-warn">还差:{blank.map((f) => f.label).join('、')}</span>}
<button className="jc-btn" disabled={blank.length > 0} onClick={() => onDone(vals)}>
<Ico name="database" s={13} /> 确认写入
</button>
</div>
)}
</>
);
}