E04 修到零被拒线,harness 补七刀:跨进程租约与广播桥、原子写、引用墙、对话区按序号排

活动侧(E04 2.1.0 → 2.1.9,I01 1.2.2):
- 覆盖闭合成为机检:基座新增 distinct 读数,「计划盖住的客户数 = 候选行数」钉进
  S3 收步 / S4 哨兵 / 放行 L2;人加的候选客户不再被整单无视
- 「关键人待识别」占位句式全链退役:查无联系人先发数据录入卡收人;契约新增 refersTo,
  计划/回执的 contact_code 只许引用真实存在的联系人(安装期核引用目标)
- 台账更新确认摆全落库面:客户档案/联系人档案两张落库预览(touched: 数据源,
  正式现值 + 草稿叠加),可补改、可加行(自增主键由基座续号);姓名升必填
- 更新明细:update_key 位置键 + 「同一处只留一条」L2;依据写人话不带机器键;
  标题旁不摆单号;判据与文案不夹字段名;行标识去掉单标识那一段
- 回执骨架 = 计划行数钉进 S3 收步与 S4 哨兵;重做分支不许删计划凑数
- 阶段刻度对齐文档 7 步;起单样例预填满

基座侧:
- 两个后端连同一个库:task-claim 跨进程租约(迁移 0030)+ Postgres LISTEN/NOTIFY
  广播桥;对话区按任务内记忆序号排,不按墙上时钟;并卡「刚说过话」按记忆序列判紧邻
- 多行 write 整批先验后写(dryRun),被拒 = 一行都没落
- 决策卡意见与本单草稿字面比对,归属以观察进轨迹(note-anchors)
- 括号栈补「补闭括号」两形(少一个 } / 行对象没关直接跟下一行)
- 件上加行:空着的自增主键直进续号,不从别的行借号;未落下的行点名回给前端
- 人答复落库那一刻就把 runtime 翻 running(task.wake),两块同帧变脸
- 试跑单可落真库(land_master,迁移 0031,默认开);数据域按活动分组;
  JSON 列不再是 [object Object];按钮键感 + 在办进度条 + 防抖
- 报价链 A1–A7 从系统卸载(只卸不删源码),种子只装 E04/I01

契约变更(api-report 已刷新):FieldDeclaration.distinct / refersTo,
objectDeclaration.file,landMaster,unkeyed,assetFiles,ledgerByActivityRoute。
1700 测 / typecheck / lint / depcruise / api:check 绿。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EEJX8Z7CHejvwmDQyPQuBX

apps/api/src/modules/llm/__tests__/parse-json-loose.test.ts

@@ -41,4 +41,44 @@ describe('parseJsonLoose:模型出参的宽容提取', () => {
   it('实在不是 JSON:undefined,不抛', () => {
     expect(parseJsonLoose('这不是 JSON')).toBeUndefined();
   });
+
+  /*
+   * 2026-08-24 实测形(E04 收口拍,全流程括号最深的输出):模型在 profile 行上
+   * **少吐了一个 `}`** —— 行对象没关上,后面关 rows 的 `]` 被 drop 档当噪声丢掉,
+   * 整段错位、到尾配不平,两连败退化成兜底卡。close 档把欠的那个补上。
+   */
+  it('**少吐一个闭括号:自动补上,整拍不作废**(实测形状,E04 收口拍)', () => {
+    // 第一行 patch 后少了关「行对象」的 } —— ]}]},{ 处 drop 档会把 ] 丢掉
+    const slip =
+      '{"say":"收口","actions":[' +
+      '{"kind":"write","address":"customer.profile","rows":[{"key":{"customer_code":"CU-0142"},' +
+      '"patch":{"decision_chain":{"nodes":[{"node":"bt-01","covered":true}]}}]},' +
+      '{"kind":"write","address":"crm_coverage.candidate","rows":[{"key":{"customer_code":"CU-0142"},"patch":{"status":"covered"}}]}]}';
+    const got = parseJsonLoose(slip) as { actions: Array<{ kind: string; address: string }> };
+    expect(got.actions.map((a) => a.kind)).toEqual(['write', 'write']);
+    expect(got.actions[1]?.address).toBe('crm_coverage.candidate');
+  });
+
+  it('输出被截断(结尾整段闭括号没吐):欠的全补上,能救就救', () => {
+    const cut = '{"say":"写一半断了","actions":[{"kind":"write","rows":[{"patch":{"a":1';
+    const got = parseJsonLoose(cut) as { actions: Array<{ kind: string }> };
+    expect(got.actions[0]?.kind).toBe('write');
+  });
+
+  it('**少括号的第二形:行对象没关、后面直接跟下一行** —— 对象里逗号后冒出 { 就是上一个没关(实测形状)', () => {
+    // rows 第一行的 } 少了,紧接着 ,{"key"… —— 括号到尾能配平,strict 与前两档全看不出
+    const slip =
+      '{"say":"收口","actions":[{"kind":"write","address":"customer.profile","rows":[' +
+      '{"key":{"customer_code":"CU-0142"},"patch":{"decision_chain":{"nodes":[{"node":"bt-01"}]}},' +
+      '{"key":{"customer_code":"CU-E2E-ADD"},"patch":{"coverage_score":0}}]}]}';
+    const got = parseJsonLoose(slip) as { actions: Array<{ rows: Array<{ key: { customer_code: string } }> }> };
+    expect(got.actions[0]?.rows.map((r) => r.key.customer_code)).toEqual(['CU-0142', 'CU-E2E-ADD']);
+  });
+
+  it('两档顺序不能反:多括号那形仍走 drop 档,行动串一个不丢', () => {
+    // 与上面「多吐一个闭括号」同形 —— close 档若先跑,会提前关掉 actions 把 finish 截掉
+    const slip = '{"say":"x","actions":[{"kind":"write","rows":[{"patch":{"t":"A"}}]}},{"kind":"finish","itemId":"S1"}]}';
+    const got = parseJsonLoose(slip) as { actions: Array<{ kind: string }> };
+    expect(got.actions.map((a) => a.kind)).toEqual(['write', 'finish']);
+  });
 });

apps/api/src/modules/llm/internal/adapter/ai-sdk-provider.ts

@@ -95,7 +95,12 @@ export function parseJsonLoose(text: string): unknown {
   try {
     return JSON.parse(candidate);
   } catch {
-    return firstBalanced(candidate);
+    /*
+     * 两档修复**有序**:先按「多余闭括号当噪声丢」(2026-08-02 那形),
+     * 不行再按「缺失闭括号自动补」(2026-08-24 那形)—— 顺序不能反:
+     * 补括号那一档对「多括号」的输出会提前把外层对象关掉,行动串被截半。
+     */
+    return firstBalanced(candidate, 'drop') ?? firstBalanced(candidate, 'close');
   }
 }
 
@@ -117,20 +122,39 @@ export function parseJsonLoose(text: string): unknown {
  * 后面多出来的照旧当噪声 —— 多写的那一份本就是下一拍的事。
  * 字符串与转义照认,否则值里带 `}` 的会把栈带偏。
  */
-function firstBalanced(text: string): unknown {
+/*
+ * ── 2026-08-24:少一个闭括号的形,丢字符治不了,得**补** ────────────────
+ *
+ * E04 收口那一拍是全流程括号最深的输出(decision_chain + interaction_timeline
+ * 两个嵌套 JSON 列),关思考的模型在 profile 行上少吐了一个 `}`:
+ * `…"contactCode":"CU-0142-01"}]}}]}` —— 行对象没关上,后面的 `]`(关 rows)
+ * 在栈眼里就成了「对不上的闭括号」被当噪声丢掉,整段从此错位、到尾都配不平,
+ * 解析两连败,六个动作全对的一拍退化成「需要你判断下一步」的兜底卡。
+ *
+ * `close` 档的两条规则(仍只合成闭括号,不发明任何内容):
+ *   · 闭括号对不上栈顶、但**栈更深处有它** → 把中间欠的闭括号补上再收它
+ *     (那正是模型漏写的那几个);栈里压根没有 → 还是噪声,丢;
+ *   · 文本走完栈没清空(输出被截断的形)→ 把欠的全补上。
+ */
+function firstBalanced(text: string, mode: 'drop' | 'close'): unknown {
   const start = text.search(/[[{]/);
   if (start < 0) return undefined;
   const stack: string[] = [];
   const kept: string[] = [];
   let inString = false;
   let escaped = false;
+  /** 上一个串外的有意义字符 —— close 档靠它认「对象里逗号后面冒出了 { 」 */
+  let lastSignificant = '';
   for (let i = start; i < text.length; i += 1) {
     const ch = text[i] as string;
     if (inString) {
       kept.push(ch);
       if (escaped) escaped = false;
       else if (ch === '\\') escaped = true;
-      else if (ch === '"') inString = false;
+      else if (ch === '"') {
+        inString = false;
+        lastSignificant = '"';
+      }
       continue;
     }
     if (ch === '"') {
@@ -139,14 +163,35 @@ function firstBalanced(text: string): unknown {
       continue;
     }
     if (ch === '{' || ch === '[') {
+      /*
+       * 2026-08-24 第二种少括号形:行对象没关上,后面直接跟 `,{"key":…`(下一行)。
+       * 括号本身到尾都能配平(少的那个 `}` 被后面某个多出来的位置吃掉),strict 与
+       * 前两档全看不出 —— 但**对象里逗号后面只能跟键名**,冒出 `{`/`[` 一定是上一个
+       * 对象没关。close 档:把欠的 `}` 补在那个逗号之前(逗号其实属于外层数组)。
+       */
+      if (mode === 'close' && lastSignificant === ',' && stack[stack.length - 1] === '}') {
+        const comma = kept.lastIndexOf(',');
+        if (comma >= 0) {
+          kept.splice(comma, 0, '}');
+          stack.pop();
+        }
+      }
       stack.push(ch === '{' ? '}' : ']');
       kept.push(ch);
+      lastSignificant = ch;
       continue;
     }
     if (ch === '}' || ch === ']') {
-      if (stack[stack.length - 1] !== ch) continue; // 对不上的闭括号 = 噪声,丢
+      if (stack[stack.length - 1] !== ch) {
+        // 对不上的闭括号:drop 档当噪声丢;close 档若栈更深处有它,先把欠的补上
+        if (mode === 'drop' || !stack.includes(ch)) continue;
+        while (stack.length > 0 && stack[stack.length - 1] !== ch) {
+          kept.push(stack.pop() as string);
+        }
+      }
       stack.pop();
       kept.push(ch);
+      lastSignificant = ch;
       if (stack.length === 0) {
         try {
           return JSON.parse(kept.join(''));
@@ -157,6 +202,16 @@ function firstBalanced(text: string): unknown {
       continue;
     }
     kept.push(ch);
+    if (!/\s/.test(ch)) lastSignificant = ch;
+  }
+  // 文本走完栈没清空:close 档把欠的闭括号全补上(输出被截断的形);drop 档照旧作废
+  if (mode === 'close' && stack.length > 0) {
+    while (stack.length > 0) kept.push(stack.pop() as string);
+    try {
+      return JSON.parse(kept.join(''));
+    } catch {
+      return undefined;
+    }
   }
   return undefined;
 }