@sema-agent/client-core 0.72.11 → 0.72.13

package/dist/hitl/planReviewWire.js

@@ -41,6 +41,8 @@ import { hostLog } from '../host.js';
 import { makeEngineWireClient } from '../engineWireSdk.js';
 import { engineWireTarget } from '../engineWireTarget.js';
 import { enqueuePlanReviewOutcome } from '../notifications.js';
+import { isPlanReviewModeAfter } from './hitlBridge.js';
+import { engineCapString } from '../engineCapsCache.js';
 import { planReviewQuestionId, REOPEN_ID_TAIL } from './gateIdentity.js';
 import { notePlanReviewAnswered, notePlanReviewAnsweredFor, planReviewArmedKeyFor, registerArmedGateFor, waitForGateArmedFor, wasGateArmedFor, } from './armedGateRegistry.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
@@ -58,8 +60,42 @@ const PLAN_REVIEW_RESUME_TIMEOUT_MS = 6 * 60 * 60_000;
  */
 export const PLAN_REVIEW_APPROVE_LABEL = 'Yes, approve and run the plan';
 export const PLAN_REVIEW_REJECT_LABEL = 'No, reject it (keep planning)';
+/**
+ * 0.72.13 CC-46(engine ≥7.86.0 S-433;契约 §4c):三选卡的两个 Yes —— 对齐 CC `ExitPlanMode` 卡
+ * 「Yes, and auto-accept edits」/「Yes, and manually approve edits」。只在**双闸**都过时才出三选卡(见 {@link planReviewCardOptions}
+ * 的调用点):宿主声明这条任务是它自己用 `permissionMode:"plan"` 提交的(适用面读不到 wire)∧ 引擎版本证据 ≥7.86.0。
+ */
+export const PLAN_REVIEW_APPROVE_AUTO_LABEL = 'Yes, and auto-accept edits';
+export const PLAN_REVIEW_APPROVE_MANUAL_LABEL = 'Yes, and manually approve edits';
+/** `permissionModeAfter` 的引擎地板(server 7.86.0;更老的 server 静默丢这个键 = 承诺了却不兑现)。 */
+export const PLAN_REVIEW_MODE_AFTER_MIN_ENGINE = Object.freeze([7, 86, 0]);
+/** 引擎版本串够不够新:三态 —— 读不出(缺席 / 非 x.y.z)⇒ `unknown`,**不折 supported**(没证据不许出三选卡)。 */
+export function versionSupportsPlanReviewModeAfter(v) {
+    // 🔴 **整串**匹配正式版 x.y.z(无前导零):预发布(7.86.0-rc.1 可能还没实现这一位)/ 尾随垃圾 / v 前缀 / 空白 一律 unknown ——
+    //    它们不是支持证据(异源对抗复审:前缀匹配曾把这些都放行,宿主声明为 true 时三选卡就出了,而老引擎静默丢键)。
+    const mm = v ? /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(v) : null;
+    if (!mm)
+        return 'unknown';
+    const got = [Number(mm[1]), Number(mm[2]), Number(mm[3])];
+    for (let i = 0; i < 3; i++) {
+        const g = got[i];
+        const need = PLAN_REVIEW_MODE_AFTER_MIN_ENGINE[i];
+        if (g !== need)
+            return g > need ? 'supported' : 'unsupported';
+    }
+    return 'supported';
+}
 const APPROVE_LABEL = PLAN_REVIEW_APPROVE_LABEL;
 const REJECT_LABEL = PLAN_REVIEW_REJECT_LABEL;
+/** 老两选卡的标签集 = 判读口不给展示标签时的缺省读域。 */
+const LEGACY_TWO_CHOICE_LABELS = Object.freeze([PLAN_REVIEW_APPROVE_LABEL, PLAN_REVIEW_REJECT_LABEL]);
+/** 四个已知标签(只供**记账**口判「是不是一次决断性作答」,不驱动任何决断)。 */
+const ALL_KNOWN_LABELS = Object.freeze([
+    PLAN_REVIEW_APPROVE_AUTO_LABEL,
+    PLAN_REVIEW_APPROVE_MANUAL_LABEL,
+    PLAN_REVIEW_APPROVE_LABEL,
+    PLAN_REVIEW_REJECT_LABEL,
+]);
 /**
  * REF-CC-026:三值判决(此前 `selected === APPROVE_LABEL ? 'approve' : 'reject'` 把「没读懂/没
  * 选」的第三种输入静默塌缩进危险的 reject 臂——overlay 的 dismiss/拒答语义是「送空 answers」,
@@ -67,14 +103,55 @@ const REJECT_LABEL = PLAN_REVIEW_REJECT_LABEL;
  * (含 undefined)落 `'dismissed'`,由调用方决定是保持 park 还是显式当 reject 处理——本函数只
  * 负责如实分类,不替调用方做选择。
  */
-export function planReviewDecisionFromAnswer(answer) {
-    const selected = answer?.answers?.[0]?.selected?.[0];
+export function planReviewDecisionFromAnswer(answer, 
+/** 本次实际展示的那张卡的标签;不给 = 老两选(见 {@link planReviewChoiceFromAnswer})。 */
+shownLabels) {
+    const choice = planReviewChoiceFromAnswer(answer, shownLabels);
+    if (choice === 'dismissed')
+        return 'dismissed';
+    return choice.decision;
+}
+export function planReviewChoiceFromAnswer(answer, 
+/**
+ * 本次**实际展示**的那张卡的标签(`planReviewCardOptions(offer).map(o => o.label)`);只认其中的标签。
+ * 🔴 **不给 = 老两选**:三选卡的两个 Yes 只有调用方显式说「我展示的是三选卡」才读得成批准 —— 缺省不许替老调用方
+ *    悄悄扩大批准的输入域(异源对抗复审:重开腿恒两选,缺省放行时一个没展示过的 auto 标签会被投递成 approve)。
+ */
+shownLabels = LEGACY_TWO_CHOICE_LABELS) {
+    // 🔴 这是一张**单选**卡,而其中一项在安全轴上(批准后放宽写征询):恰一题、恰一项才算作答。矛盾多选(`[auto, reject]`)/
+    //    多题 / 空 selected 一律 dismissed —— 此前只取 `selected[0]`,拒绝意图会被丢弃、放宽被执行(异源对抗复审 [high])。
+    const answers = answer?.answers;
+    if (!Array.isArray(answers) || answers.length !== 1)
+        return 'dismissed';
+    const picked = answers[0]?.selected;
+    if (!Array.isArray(picked) || picked.length !== 1)
+        return 'dismissed';
+    const selected = picked[0];
+    // 标签必须属于这次展示的卡:两选卡上不存在「auto-accept edits」,收到它 = 答的不是这张卡。
+    if (typeof selected !== 'string' || !shownLabels.includes(selected))
+        return 'dismissed';
+    if (selected === PLAN_REVIEW_APPROVE_AUTO_LABEL)
+        return { decision: 'approve', permissionModeAfter: 'acceptEdits' };
+    if (selected === PLAN_REVIEW_APPROVE_MANUAL_LABEL)
+        return { decision: 'approve', permissionModeAfter: 'default' };
     if (selected === APPROVE_LABEL)
-        return 'approve';
+        return { decision: 'approve' };
     if (selected === REJECT_LABEL)
-        return 'reject';
+        return { decision: 'reject' };
     return 'dismissed';
 }
+/** 卡选项的**单源**:`offerModeAfter=false` ⇒ 老两选(逐字同旧);`true` ⇒ 三选(两个 Yes + No)。 */
+export function planReviewCardOptions(offerModeAfter) {
+    const reject = { label: REJECT_LABEL, description: 'Discard this plan and stay in plan mode to refine it' };
+    if (!offerModeAfter) {
+        return [{ label: APPROVE_LABEL, description: 'Resume the task now and execute the plan (runs to completion engine-side)' }, reject];
+    }
+    return [
+        { label: PLAN_REVIEW_APPROVE_AUTO_LABEL, description: 'Resume and execute the plan; edits inside the working directory are not asked about one by one' },
+        { label: PLAN_REVIEW_APPROVE_MANUAL_LABEL, description: 'Resume and execute the plan; every edit still asks for approval' },
+        reject,
+    ];
+}
 /**
  * 推代的**门控口**(A-024.4;#244 F1 上收,语义照壳现实现):只有**决断性**作答(approve/
  * reject 标签命中 —— {@link planReviewDecisionFromAnswer} 的官方三值分类)才消费当代 plan 门。
@@ -90,7 +167,8 @@ export function notePlanReviewAnsweredIfDecisive(questionId, answer) {
 }
 /** W1 带 key 变体。 */
 function notePlanReviewAnsweredIfDecisiveFor(sessionKey, questionId, answer) {
-    if (planReviewDecisionFromAnswer(answer ?? { answers: [] }) === 'dismissed')
+    // 记账口:两种卡的任一已知标签都算决断性作答(这里不投递决断;投递侧各自按**自己展示的卡**校验标签)。
+    if (planReviewDecisionFromAnswer(answer ?? { answers: [] }, ALL_KNOWN_LABELS) === 'dismissed')
         return;
     notePlanReviewAnsweredFor(sessionKey, questionId);
 }
@@ -121,9 +199,15 @@ export function isPlanReviewPark(result) {
  * `registerLocalQuestionResponder` 调用。
  */
 const armedPlanReviewTaskIds = new Set();
+/**
+ * 0.72.13 CC-46:这张已武装的卡**出的是不是三选卡**(两个 Yes 各带一档批准后模式)。与 {@link armedPlanReviewTaskIds}
+ * 同生命周期(arm 写、决断性作答 / arm 失败清);重放重呈读它,保证同一张卡前后两次呈现选项一致。缺席 = 老两选。
+ */
+const offerModeAfterByTask = new Map();
 /** 测试钩:清掉武装态(不动 liveQuestionStore 本身,那边有自己的 reset)。 */
 export function _resetArmedPlanReviewsForTest() {
     armedPlanReviewTaskIds.clear();
+    offerModeAfterByTask.clear();
 }
 /* 合成 questionId 的唯一铸口:A-028.3 起收编进 `gateIdentity.planReviewQuestionId`(公面导出,
  * 壳侧重开腿从此 import 同一铸口,不再手抄字面)。本文件只 import,不再自铸。 */
@@ -132,15 +216,13 @@ const ARM_QUESTION = 'The plan is ready for review. Approve it and start the imp
 /** 重开腿的题面正句(点明「这张卡就是占住会话的那件事」;标签/选项与首呈同源)。 */
 const REOPEN_QUESTION = 'This plan is still waiting for your review — it is what is holding this session. Approve it and start the implementation?';
 /** 题面唯一构造点 —— 首次 arm、重放重呈、重开三处共用,标签/选项描述不许各写一份。 */
-function planReviewQuestions(question) {
+function planReviewQuestions(question, offerModeAfter = false) {
     return [
         {
             header: 'Plan review',
             question,
-            options: [
-                { label: APPROVE_LABEL, description: 'Resume the task now and execute the plan (runs to completion engine-side)' },
-                { label: REJECT_LABEL, description: 'Discard this plan and stay in plan mode to refine it' },
-            ],
+            // 选项单源 `planReviewCardOptions`:老两选逐字同旧;三选只在 arm 的双闸都过时出(重开腿恒老两选 = 批准不带键 ⇒ default)。
+            options: planReviewCardOptions(offerModeAfter),
             multiSelect: false,
         },
     ];
@@ -150,7 +232,7 @@ function publishPlanReviewCard(taskId) {
     publishQuestionFrame({
         type: 'question',
         questionId: planReviewQuestionId(taskId),
-        questions: planReviewQuestions(ARM_QUESTION),
+        questions: planReviewQuestions(ARM_QUESTION, offerModeAfterByTask.get(taskId) === true),
     });
 }
 /**
@@ -159,7 +241,13 @@ function publishPlanReviewCard(taskId) {
  * REF-CC-027 above); false = caller renders the terminal as usual. Fail-soft: any error inside must
  * never break the stream drain.
  */
-export function armPlanReviewApproval(result, sessionKey) {
+export function armPlanReviewApproval(result, sessionKey, 
+/**
+ * 0.72.13 CC-46:`submittedInPlanMode: true` = 宿主声明「这条任务是我用 `permissionMode:"plan"` 提交的」(只读起步)。
+ * 🔴 这件事**读不到 wire 上**(契约 §4c:两种任务产出同一张卡),所以只能由提交方声明;不声明 / false ⇒ 老两选卡、决断体不带键。
+ * 声明了还要过第二道闸:本进程 caps 缓存里的引擎版本 ≥7.86.0(更老的 server 静默丢这个键 = 卡上承诺了却不兑现)。
+ */
+opts) {
     let armedTaskId;
     try {
         if (!isPlanReviewPark(result))
@@ -227,6 +315,13 @@ export function armPlanReviewApproval(result, sessionKey) {
         }
         armedPlanReviewTaskIds.add(taskId);
         armedTaskId = taskId;
+        // CC-46 双闸:宿主声明 ∧ 引擎版本证据(读不出 ⇒ unknown ⇒ 不出三选卡)。
+        const offerModeAfter = opts?.submittedInPlanMode === true &&
+            versionSupportsPlanReviewModeAfter(engineCapString(engineWireTarget()?.baseUrl, 'version')) === 'supported';
+        if (offerModeAfter)
+            offerModeAfterByTask.set(taskId, true);
+        else
+            offerModeAfterByTask.delete(taskId);
         const questionId = planReviewQuestionId(taskId);
         const unregister = registerLocalQuestionResponder(questionId, async (_id, answer) => {
             // REF-CC-027:一次性 —— 首句就注销 + 清武装态(照 askGateWire 的 cleanup() 形)。
@@ -234,19 +329,24 @@ export function armPlanReviewApproval(result, sessionKey) {
             // 第二道钉:武装态一清,同 taskId 才能重新正常 arm(证明 responder 真的落定了)。
             unregister();
             armedPlanReviewTaskIds.delete(taskId);
-            const decided = planReviewDecisionFromAnswer(answer);
-            if (decided === 'dismissed') {
+            const shown = planReviewCardOptions(offerModeAfterByTask.get(taskId) === true).map(o => o.label);
+            const choice = planReviewChoiceFromAnswer(answer, shown);
+            if (choice === 'dismissed') {
                 // dismiss/无法判读:诚实缺席优先于编造默认值(REF-CC-026)——不静默驱动 decidePlanReview,
                 // 卡的重开路径把决定权还给用户。呈现台账的键**不清**:同一张卡再被重开就是真「reopened」。
                 return { ok: true };
             }
+            const decided = choice.decision;
+            // CC-46:只有三选卡的两个 Yes 带批准后模式;老两选的 Yes / No 不带 ⇒ 决断体不落键。
+            const modeAfter = choice.decision === 'approve' ? choice.permissionModeAfter : undefined;
+            offerModeAfterByTask.delete(taskId);
             // A-024.4(#244 F1 起走分代):决断一经递交,这个门的呈现史就消费掉(当代键清 + 推代);
             // 同 run 的**下一个** plan gate(approve 推进后引擎可再 park 一个新 plan)必须读回首见,
             // 否则文案对一张从未呈现过的新卡说「reopened」。递交后决定未生效的形(RB-471 族)读回
             // 首见只损失「reopened」一词 —— 首见文案零历史断言,诚实方向安全。
             notePlanReviewAnswered(questionId);
             // fire-and-forget:resume 同步驱动到终态可能分钟级,不能挂住 overlay;结果经 queue 通知回来
-            void decidePlanReview(taskId, decided);
+            void decidePlanReview(taskId, decided, modeAfter);
             return { ok: true };
         });
         publishPlanReviewCard(taskId);
@@ -256,8 +356,10 @@ export function armPlanReviewApproval(result, sessionKey) {
     catch (e) {
         // REF-CC-027:arm 本身失败(register/publish 抛)绝不能把 taskId 永久锁在武装态里
         // ——那样这张卡再也无法被正常 arm 一次。
-        if (armedTaskId !== undefined)
+        if (armedTaskId !== undefined) {
             armedPlanReviewTaskIds.delete(armedTaskId);
+            offerModeAfterByTask.delete(armedTaskId);
+        }
         hostLog('debug', `planReviewWire: arm failed (fail-soft): ${String(e)}`);
         return false;
     }
@@ -267,7 +369,13 @@ export function armPlanReviewApproval(result, sessionKey) {
  *  plan_review` 同 body {decision})——raw fetch 退役。错误模型:非 2xx 抛 APIError(message =
  *  server body.error 原文)→ 同款「HTTP <status> <error>」outcome 文案;网络失败走原「could not
  *  reach the engine」臂。 */
-export async function decidePlanReview(taskId, decision) {
+export async function decidePlanReview(taskId, decision, 
+/**
+ * 0.72.13 CC-46(engine ≥7.86.0;契约 §4c):批准之后用哪一档。缺席 ⇒ 体逐字节同旧 `{decision}`。只配 approve、闭集两词 ——
+ * 坏形本地拒(零 POST,outcome 如实说没送出去,不回显值)。引擎答 400 `request.field_conflict`(这条任务不是只读起步):
+ * `default` 与缺席同义 ⇒ 去键重发恰一次;`acceptEdits` **不**重发(不静默降成逐次征询),outcome 说批准没生效。
+ */
+permissionModeAfter) {
     // REF-CC-025:此前 `cfg`/`client` 缺席各自 `return` 静默——卡已经对用户回了「收到」
     // (armPlanReviewApproval 的 responder 早就 `return {ok:true}` 过了),但决断本身连一次网络
     // 请求都没发出去,而模型/用户没有任何回程信号。两条早退现在都汇进同一条 outcome 管道(下方
@@ -276,7 +384,12 @@ export async function decidePlanReview(taskId, decision) {
     // 🔴 design/285 批 3 显式裁定:本处与 `armPlanReviewApproval` 同一笔豁免(理由逐字见那边)——
     //    决断是从 arm 立的那张卡的 responder 回调进来的,槽键必须与立卡时同源,单换这一跳即两头不一致。
     const cfg = engineWireTarget();
-    if (!cfg) {
+    const badMode = permissionModeAfter !== undefined && (decision !== 'approve' || !isPlanReviewModeAfter(permissionModeAfter));
+    if (badMode) {
+        hostLog('error', `planReviewWire: ${decision} NOT sent — permissionModeAfter is only valid with approve and must be "default" or "acceptEdits"`);
+        outcome = `The plan_review ${decision} could NOT be sent: the post-approval permission mode given with it is not valid for this decision (it only applies to an approval, and must be "default" or "acceptEdits"). Tell the user plainly that the decision did not go through; the plan is still waiting.`;
+    }
+    else if (!cfg) {
         hostLog('error', `planReviewWire: ${decision} NOT sent — engineWireTarget() unavailable`);
         outcome = `The plan_review ${decision} could NOT be sent: no engine connection is configured on this host. Tell the user plainly that the decision did not go through.`;
     }
@@ -293,7 +406,27 @@ export async function decidePlanReview(taskId, decision) {
         }
         else {
             try {
-                const body = await client.assistant.planReview(taskId, { decision });
+                // sdk 9.6.0 的 PlanReviewRequest 未声明 permissionModeAfter ⇒ 交集型加一可选位;缺席 = 键不落(体逐字节同旧)。
+                const mode = isPlanReviewModeAfter(permissionModeAfter) ? permissionModeAfter : undefined;
+                const reqBody = { decision };
+                if (mode !== undefined)
+                    reqBody.permissionModeAfter = mode;
+                let body;
+                try {
+                    body = await client.assistant.planReview(taskId, reqBody);
+                }
+                catch (e1) {
+                    // 400 request.field_conflict + 带了 default:default ≡ 缺席(契约:缺席 = 这一档)⇒ 去键重发恰一次,零语义损失。
+                    // 被这道门拒掉的请求一个字节的状态都不动(契约),同一次批准可原样重试。acceptEdits 不走这里(见下方 catch)。
+                    const conflict = e1;
+                    if (mode === 'default' && conflict?.status === 400 && conflict?.errorCode === 'request.field_conflict') {
+                        hostLog('debug', 'planReviewWire: permissionModeAfter "default" refused as not applicable — re-sending the approval without the key (same meaning)');
+                        body = await client.assistant.planReview(taskId, { decision });
+                    }
+                    else {
+                        throw e1;
+                    }
+                }
                 hostLog('debug', `planReviewWire: ${decision} → ok ${JSON.stringify(body).slice(0, 200)}`);
                 // [2315]/[2316](#109,2026-08-02):decide 的 **2xx 不当终态** —— test 黑盒实测 reject 9/9
                 // 返回 200 而会话仍锁在同一 gate(core RB-471:重开兜底对 reject 腿恒真误触发)。这里回拉
@@ -341,7 +474,16 @@ export async function decidePlanReview(taskId, decision) {
             catch (e) {
                 // APIError 判型走 status duck-check(sseIdleTriage 同款纪律:双包时 instanceof 会分叉)。
                 const status = e?.status;
-                if (typeof status === 'number') {
+                const refusedCode = e?.errorCode;
+                if (status === 400 && refusedCode === 'request.field_conflict' && permissionModeAfter === 'acceptEdits') {
+                    // CC-46:这条任务不是只读起步的(模型自选 plan 模式那种形)⇒ 引擎拒收「批准后自动接受编辑」。**不**静默降档重发:
+                    // 用户选的是「不再逐次征询」,悄悄换成「逐次征询」= 替他改了决定。引擎一个字节的状态都没动,计划仍在等。
+                    hostLog('debug', 'planReviewWire: approve + acceptEdits refused (request.field_conflict) — NOT re-sent with a different mode');
+                    outcome =
+                        'The plan approval was NOT applied: the engine refused "auto-accept edits" for this task (it was not started read-only in plan mode, so that option does not apply). ' +
+                            'Nothing changed engine-side — the plan is still waiting for review. Tell the user plainly, and that approving with "manually approve edits" will go through.';
+                }
+                else if (typeof status === 'number') {
                     const msg = e instanceof Error ? e.message : String(e);
                     hostLog('debug', `planReviewWire: ${decision} → ${status} ${msg.slice(0, 200)}`);
                     outcome = `The plan_review decision failed: HTTP ${status} ${msg}`.trim();
@@ -450,14 +592,15 @@ export function reopenPlanReviewCard(taskId, opts) {
                 publishQuestionFrameFor(sessionKey, {
                     type: 'question',
                     questionId: canonicalId,
-                    questions: planReviewQuestions(ARM_QUESTION),
+                    questions: planReviewQuestions(ARM_QUESTION, offerModeAfterByTask.get(taskId) === true),
                 });
                 return settleOnReceipt(receipt, firstSight);
             }
             publishQuestionFrameFor(sessionKey, {
                 type: 'question',
                 questionId: canonicalId,
-                questions: planReviewQuestions(ARM_QUESTION),
+                // 🔴 沿用 arm responder ⇒ 题面必须是**那张卡**的选项(三选 arm 后重绘成两选 = 屏上的 Yes 不在 responder 的读域里,点了不投递)。
+                questions: planReviewQuestions(ARM_QUESTION, offerModeAfterByTask.get(taskId) === true),
             });
             registerArmedGateFor(sessionKey, armedKey);
             return { reopened: true, firstSight };
@@ -489,7 +632,8 @@ export function reopenPlanReviewCard(taskId, opts) {
             if (activeReopenResponders.get(activeKey)?.questionId === questionId) {
                 activeReopenResponders.delete(activeKey);
             }
-            const decided = planReviewDecisionFromAnswer(answer);
+            // 本腿展示的恒是老两选 ⇒ 显式按两选标签校验(未展示的 auto / manual 标签 = 答的不是这张卡 ⇒ dismissed)。
+            const decided = planReviewDecisionFromAnswer(answer, LEGACY_TWO_CHOICE_LABELS);
             if (decided === 'dismissed') {
                 // 三态(REF-CC-026):dismiss/读不出不驱动 decidePlanReview;呈现台账不清 ——
                 // 这张卡再被重开就是真「reopened」。

package/dist/index.d.ts

@@ -155,6 +155,7 @@ export * from './engineCapsCache.js';
 export * from './sqlEngineCapability.js';
 export * from './writeProtectionCapability.js';
 export * from './webSearchBackendCapability.js';
+export * from './executionLaneCapability.js';
 export * from './mcpReconnect.js';
 export * from './leaderConflict.js';
 export * from './runTerminal.js';

package/dist/index.js

@@ -187,6 +187,9 @@ export * from './writeProtectionCapability.js';
 // S-382(0.72.5;server ≥7.82.1,sdk 尚未声明):`Capabilities.webSearch.backend` 的四态窄读器 ——
 // 部署默认 WebSearch 后端(`none` = 正面事实 / 键缺席 = 老引擎判不了,两者处置相反)。与上两只同构同纪律。
 export * from './webSearchBackendCapability.js';
+// 0.72.13 CC-54:`capabilities.executionLane`(server ≥7.86.0 S-426)四态读面 —— 键缺席 = 老 server 判不了(≠ 不是本机车道);
+// 「工具是否跑在本机」判据归包(读到位用位,读不到原样用调用方旁证)。
+export * from './executionLaneCapability.js';
 // S-381 / core 7.22.0 #857(0.72.9 CC-30;server ≥7.85.0,sdk 尚未声明):会话内 MCP re-dial 的消费口 —— 200 三态按 outcome 分形读、
 // unsupported 恒五键、名册按 toolNames 在场性、失败按 errorCode 分诊、「重连 = 一次交易」措辞单源;能力位 mcpReconnect 三态读。
 export * from './mcpReconnect.js';

package/dist/notifications.d.ts

@@ -1,6 +1,6 @@
 /**
  * ⚠️ 调用方契约(交叉复审 [MED] 登记):cli 原版在渲染前有两条默认值回填——
- *   summary 缺省 ⇒ `Background task "${taskId}" ${status}`;status 非串 ⇒ 'completed'。
+ *   summary 缺省 ⇒ `Background task "${taskId}" ${status}`;status 非串 ⇒ 'unknown'(0.72.12 起;此前 'completed')。
  * 本纯函数不做回填(职责在 adapt() 输入侧),直接透传引擎原始 JSON 会渲出空 <summary>。
  * 落 adapt() 时必须先补齐这两个字段再调本函数。
  * 另注:<status> 段转义为**有意统一变更**(cli 原版曾不转义;2026-07-25 双侧统一为转义,
@@ -35,7 +35,7 @@ export declare function renderTaskNotificationXml(n: TaskNotificationFields): st
 export declare function deriveNotificationResidualLines(n: Record<string, unknown>): string[];
 /**
  * 引擎 task_notification 原始 payload → renderTaskNotificationXml 的入参(**含上面注释里那两条
- * 回填**:summary 缺省 ⇒ `Background task "<id>" <status>`;status 非串 ⇒ 'completed')。
+ * 回填**:summary 缺省 ⇒ `Background task "<id>" <status>`;status 非串 ⇒ 'unknown',summary 改说 outcome unknown)。
  * task_id 空串/缺失 ⇒ null(RB-75 同族:空 id 会塌成 ':status' 共享桶互吞,无 id 的通知本就无意义)。
  * 字段名映射按 wire 真形:task_id/output_file/task_type/source 是 snake/wire 名,其余同名。
  */

package/dist/notifications.js

@@ -9,7 +9,7 @@ import { unrefTimer } from './unrefTimer.js';
 import { clearEnginePanelTaskResident, publishEngineAgentPanelEvent, } from './engineAgentPanelStore.js';
 // L-215②(0.65.0;core [6908]):「非成功终局」的**单铸谓词** —— 面板 settle 的 `isError` 位与
 // 三端自己的后台白名单必须读同一个判据;内联一个 `=== 'failed' || === 'killed'` 就是第二份会漂的台账。
-import { isTerminalNotSuccess, isTerminalStatus } from './runTerminal.js';
+import { isTaskNotificationTerminalStatus, isTerminalNotSuccess, isTerminalStatus } from './runTerminal.js';
 function escapeXml(v) {
     return v.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
@@ -58,7 +58,7 @@ export function deriveNotificationResidualLines(n) {
 }
 /**
  * 引擎 task_notification 原始 payload → renderTaskNotificationXml 的入参(**含上面注释里那两条
- * 回填**:summary 缺省 ⇒ `Background task "<id>" <status>`;status 非串 ⇒ 'completed')。
+ * 回填**:summary 缺省 ⇒ `Background task "<id>" <status>`;status 非串 ⇒ 'unknown',summary 改说 outcome unknown)。
  * task_id 空串/缺失 ⇒ null(RB-75 同族:空 id 会塌成 ':status' 共享桶互吞,无 id 的通知本就无意义)。
  * 字段名映射按 wire 真形:task_id/output_file/task_type/source 是 snake/wire 名,其余同名。
  */
@@ -66,7 +66,8 @@ export function normalizeTaskNotification(n) {
     const taskId = typeof n.task_id === 'string' && n.task_id.length > 0 ? n.task_id : undefined;
     if (taskId === undefined)
         return null;
-    const status = typeof n.status === 'string' ? n.status : 'completed';
+    // 0.72.12 CC-50(#59 A-08):status 非串 ⇒ 'unknown'(此前 'completed',并用它编 summary 与去重键)。
+    const status = typeof n.status === 'string' ? n.status : 'unknown';
     const lines = Array.isArray(n.lines)
         ? n.lines.filter((l) => typeof l === 'string')
         : [];
@@ -76,7 +77,9 @@ export function normalizeTaskNotification(n) {
         status,
         summary: typeof n.summary === 'string' && n.summary.length > 0
             ? n.summary
-            : `Background task "${taskId}" ${status}`,
+            : status === 'unknown'
+                ? `Background task "${taskId}" reported without a status (outcome unknown)`
+                : `Background task "${taskId}" ${status}`,
         ...(typeof n.task_type === 'string' ? { taskType: n.task_type } : {}),
         ...(typeof n.toolUseId === 'string' && n.toolUseId.length > 0 ? { toolUseId: n.toolUseId } : {}),
         ...(typeof n.output_file === 'string' && n.output_file.length > 0
@@ -121,7 +124,8 @@ export function taskNotificationDedupKey(n) {
 export function taskNotificationDedupKeyFromWire(n) {
     return taskNotificationDedupKey({
         taskId: typeof n.task_id === 'string' ? n.task_id : '',
-        status: typeof n.status === 'string' ? n.status : 'completed',
+        // CC-50:与 normalizeTaskNotification 同判,缺席不与真 completed 同桶。
+        status: typeof n.status === 'string' ? n.status : 'unknown',
         ...(typeof n.seq === 'number' || typeof n.seq === 'string' ? { seq: n.seq } : {}),
         ...(typeof n.task_type === 'string' ? { taskType: n.task_type } : {}),
     });
@@ -898,26 +902,37 @@ export function enqueueBgChildNotification(n) {
         return;
     }
     bgNotifiedKeys.add(key);
-    // [2393] F-1:周期维必须跟着前进 —— 收摊臂删条目的唯一证据就是这一格。
-    markRunNotified(n.taskId, cycle);
-    cardEnqueuedRunIds.add(n.taskId);
+    // 🔴 完成三本账(完成去重 / 周期 / 完成卡)与面板 settle **只认通知自己的终态词**(completed / failed / killed / cancelled)。
+    //    非终态(running / queued / event / unknown / 未来词)只过上面那本**逐条**去重账:它若占了完成账,同一任务随后的
+    //    真终态会被跨通道去重吞掉 ⇒ 零 end、常驻标永不摘(异源对抗复审)。
+    const terminal = isTaskNotificationTerminalStatus(n.status);
+    if (terminal) {
+        // [2393] F-1:周期维必须跟着前进 —— 收摊臂删条目的唯一证据就是这一格。
+        markRunNotified(n.taskId, cycle);
+        cardEnqueuedRunIds.add(n.taskId);
+    }
     // #6 通知-settle 边(合成半场):bg 子代行不再被 turn sweep 假结(session 常驻台账),真终态
     // 唯二来源 = 推送帧(bridge task_notification 臂)与本合成链(probe/fleet bg_notification 收敛点)。
     // 消费端 settle 幂等(running 才动),推送帧先到时此发布为 no-op。
-    try {
-        clearEnginePanelTaskResident(n.taskId);
-        publishEngineAgentPanelEvent({
-            kind: 'end',
-            taskId: n.taskId,
-            // L-215②(0.65.0):读**单铸谓词**而不是内联两词 —— 修前这里只认 `failed`/`killed`,
-            //    而 core [6908] 的 `blocked` 是 **agent 自报的终态**(不是等人)⇒ 一条自报走不下去的
-            //    后台 run 在面板上被 settle 成**成功**。🔴 `suspended`/`needs_review` 仍不在表里
-            //    (那两词是「等一次人的决定」,判成终局会把一条正等着你的 run 在面板上判死)。
-            isError: isTerminalNotSuccess(n.status),
-        });
-    }
-    catch {
-        /* fail-soft — 面板 settle 失败绝不挡模型通知注入 */
+    if (terminal) {
+        try {
+            // 0.72.13(test 0.72.12 验收 ①;DS-06 同形存量):只对**通知自己的终态词**(completed / failed / killed / cancelled)settle 面板行。
+            // 此前对任何 status 都铸 `end`,而 `isError: isTerminalNotSuccess(status)` 对 running / queued / event / 未来词答 false ⇒
+            // 面板把一条还在跑 / 认不出状态的行结成 **completed** —— 该谓词的 JSDoc 明禁拿它的 false 当成功。非终态 ⇒ 不 settle、常驻标不摘。
+            clearEnginePanelTaskResident(n.taskId);
+            publishEngineAgentPanelEvent({
+                kind: 'end',
+                taskId: n.taskId,
+                // L-215②(0.65.0):读**单铸谓词**而不是内联两词 —— 修前这里只认 `failed`/`killed`,
+                //    而 core [6908] 的 `blocked` 是 **agent 自报的终态**(不是等人)⇒ 一条自报走不下去的
+                //    后台 run 在面板上被 settle 成**成功**。🔴 `suspended`/`needs_review` 仍不在表里
+                //    (那两词是「等一次人的决定」,判成终局会把一条正等着你的 run 在面板上判死)。
+                isError: isTerminalNotSuccess(n.status),
+            });
+        }
+        catch {
+            /* fail-soft — 面板 settle 失败绝不挡模型通知注入 */
+        }
     }
     const message = `<${TASK_NOTIFICATION_TAG}>
 <${TASK_ID_TAG}>${escapeXml(n.taskId)}</${TASK_ID_TAG}>
@@ -1050,7 +1065,15 @@ export function taskNotificationDeliverySupplement(objective) {
         return `${SUPPLEMENT_LINE_PREFIX}completed — only this notification delivery failed. Check /tasks for the result.`;
     }
     const statusNote = status && status.length > 0 ? ` (status: ${status})` : '';
-    return `${SUPPLEMENT_LINE_PREFIX}already finished${statusNote} — only this notification delivery failed. Check /tasks for the result.`;
+    // 0.72.12 CC-50(异源对抗复审 R2 [medium]):只对**明确终态**说 already finished。此前这个尾模板对任何词都断言「已结束」,
+    // 而同批 normalizeTaskNotification 开始对缺 status 的通知铸 `unknown` ⇒ 补充行重新造出终局确定性(DS-06:兜底位置落正向词,
+    // 且模板表达式逃过 AST 五形)。缺席 / unknown / 未来词 / 活跃词 ⇒ 只陈述投递失败,不推断任务结局。
+    // 终态词表对账**通知**自己的词(单源 `runTerminal.TASK_NOTIFICATION_TERMINAL_STATUSES`),不借 run 级 `isTerminalStatus`
+    // (那张表没有 cancelled、多一个 blocked,语义不同)。
+    if (isTaskNotificationTerminalStatus(status)) {
+        return `${SUPPLEMENT_LINE_PREFIX}already finished${statusNote} — only this notification delivery failed. Check /tasks for the result.`;
+    }
+    return `${SUPPLEMENT_LINE_PREFIX}is in a state this client cannot confirm${statusNote} — this notification delivery failed and the task's outcome is unknown here. Check /tasks for its current state.`;
 }
 /**
  * API-error 行文拆分(渲染层消费):尾部的 supplement 行(若在)分离出来渲 dim,main 保留原始

package/dist/runTerminal.d.ts

@@ -313,3 +313,12 @@ export type RunTerminalStatus = (typeof RUN_TERMINAL_STATUSES)[number];
  * 🔴 表外词 ⇒ `false` = 「本端认不出这是个终局」,**不是**「它还在跑」;要判「在跑」请读正向证据。
  */
 export declare function isTerminalStatus(status: unknown): status is RunTerminalStatus;
+/**
+ * 0.72.12 CC-50:**通知**(`task_notification.status`)自己的终态词表 —— 引擎 `TaskNotificationStatus` 五词里的四个终态
+ * (`completed` / `failed` / `killed` / `cancelled`;第五词 `event` 是唯一非终态 = 仍在跑的 Monitor 批)逐字镜像。
+ * 🔴 它与 run 级 {@link RUN_TERMINAL_STATUSES} 是**两张表**(那张有 `blocked`、没有 `cancelled`):通知说「已取消」是明确终态,
+ *    借 run 级表会把它读成「认不出」(异源对抗复审抓出)。住在词表属主文件里,src 别处零内联(终态词汇门 D3)。
+ */
+export declare const TASK_NOTIFICATION_TERMINAL_STATUSES: readonly string[];
+/** 这个通知 status 是不是**明确终态**;表外词(`event` / `unknown` / 未来词 / 缺席)⇒ false = 「本端不能断言它结束了」。 */
+export declare function isTaskNotificationTerminalStatus(status: string | undefined): boolean;

package/dist/runTerminal.js

@@ -320,3 +320,14 @@ export const RUN_TERMINAL_STATUSES = Object.freeze([
 export function isTerminalStatus(status) {
     return typeof status === 'string' && RUN_TERMINAL_STATUSES.includes(status);
 }
+/**
+ * 0.72.12 CC-50:**通知**(`task_notification.status`)自己的终态词表 —— 引擎 `TaskNotificationStatus` 五词里的四个终态
+ * (`completed` / `failed` / `killed` / `cancelled`;第五词 `event` 是唯一非终态 = 仍在跑的 Monitor 批)逐字镜像。
+ * 🔴 它与 run 级 {@link RUN_TERMINAL_STATUSES} 是**两张表**(那张有 `blocked`、没有 `cancelled`):通知说「已取消」是明确终态,
+ *    借 run 级表会把它读成「认不出」(异源对抗复审抓出)。住在词表属主文件里,src 别处零内联(终态词汇门 D3)。
+ */
+export const TASK_NOTIFICATION_TERMINAL_STATUSES = Object.freeze(['completed', 'failed', 'killed', 'cancelled']);
+/** 这个通知 status 是不是**明确终态**;表外词(`event` / `unknown` / 未来词 / 缺席)⇒ false = 「本端不能断言它结束了」。 */
+export function isTaskNotificationTerminalStatus(status) {
+    return status !== undefined && TASK_NOTIFICATION_TERMINAL_STATUSES.includes(status);
+}

package/dist/toolResult.js

@@ -471,7 +471,8 @@ export function wireOutputToBody(toolName, output, isError, truncated, flatten,
             return wrap({
                 task_id: parsed.taskId ?? '',
                 task_type: 'local_agent',
-                status: parsed.status ?? 'completed',
+                // 0.72.12 CC-50(#59 A-06):解不出 ⇒ unknown,不编 completed。
+                status: parsed.status ?? 'unknown',
                 description: parsed.taskId ?? '',
                 output: parsed.output ?? '',
                 result: parsed.output ?? '',
@@ -824,19 +825,27 @@ modelText) {
             const taskId = typeof s.task_id === 'string' ? s.task_id : undefined;
             if (taskId === undefined)
                 return null;
-            const retrieval = s.retrieval_status === 'timeout' || s.retrieval_status === 'not_ready'
-                ? s.retrieval_status
-                : 'success';
             const taskType = typeof s.taskType === 'string' ? s.taskType : '';
             const inner = s.details && typeof s.details === 'object' ? s.details : undefined;
             const hasStatus = typeof s.status === 'string' && s.status.length > 0;
             const hasContent = typeof s.content === 'string';
+            // 0.72.12 CC-50(#59 A-05 前半)。🔴 `retrieval_status` 是 **CC 同名键**(闭集 success / timeout / not_ready):老壳卡片
+            // success 才展示正文、not_ready 渲「still running」、timeout 渲超时 —— 闭集里没有「不知道」,绝不往里塞第四个词。
+            // 认不出 / 缺席 ⇒ `success`:正向证据 = 这份 structured detail 是一次**已返回**的取回调用的产物(引擎没说 timeout /
+            // not_ready 就是取回来了);「结局不知道」由下面的 `status:'unknown'` 承载,不由 retrieval 位承载。
+            // (异源对抗复审两轮:原词透传 ⇒ 已完成正文被藏;按 structured 两键推 not_ready ⇒ 漏了文本回落且渲成假「仍在运行」。
+            //  本行登记在 scripts/absence-fold-baseline.json 带 why。)
+            const rawRetrieval = typeof s.retrieval_status === 'string' ? s.retrieval_status : undefined;
+            const engineSaidNotReady = rawRetrieval === 'timeout' || rawRetrieval === 'not_ready';
+            const retrieval = engineSaidNotReady ? rawRetrieval : 'success';
             // 🔴 惰性回落:structured 把 status 和正文都带齐了就**根本不解**模型面文本(T13 正则退位);
             //    少哪一半就只为那一半解一次。判据锚在「这两个量还缺不缺」,不锚在「structured 在不在」。
             const parsed = hasStatus && hasContent ? null : parseModelFacingTaskOutput(modelText ?? '');
+            // 0.72.12 CC-50(#59 A-05):retrieval success 只说「取到了」,不说「完成了」⇒ 无 status 落 unknown;
+            // 引擎**亲口**说 not_ready / timeout 才是「还没好」的正向证据 ⇒ running(本包按无证据推出来的 not_ready 不算)。
             const status = hasStatus
                 ? s.status
-                : (parsed?.status ?? (retrieval === 'success' ? 'completed' : 'running'));
+                : (parsed?.status ?? (engineSaidNotReady ? 'running' : 'unknown'));
             // 'unknown' 分支类型上没有 output 字段(REF-CC-TYPESHAPE-14:不是「值恰好是 undefined」)——
             // 显式按 kind 取,别对整个 union 裸访问不共有的属性。
             const bodyText = hasContent ? s.content : parsed && parsed.kind !== 'unknown' ? parsed.output : undefined;

package/dist/workflow.js

@@ -69,7 +69,9 @@ export function parseWorkflowPollEnvelope(body) {
             return null;
         return {
             taskId: j.task_id,
-            status: typeof j.status === 'string' && j.status.length > 0 ? j.status : 'completed',
+            // 0.72.12 CC-50(#59 A-07):缺 status ⇒ 'unknown'。此前折成 'completed',而 'completed' ∈ WF_TERMINAL ⇒
+            // 消费点顺手 markEngineWorkflowNotified,把真完成通知的补发通道一起缴械。缺席不是终局。
+            status: typeof j.status === 'string' && j.status.length > 0 ? j.status : 'unknown',
             ...(typeof j.name === 'string' && j.name.length > 0 ? { name: j.name } : {}),
         };
     }