@sema-agent/client-core 0.72.7 → 0.72.9

package/dist/mcpReconnect.js

@@ -0,0 +1,235 @@
+/**
+ * mcpReconnect — 会话内 MCP re-dial 的**三端共用消费口**(0.72.9 CC-30;server ≥7.85.0 S-381 / core 7.22.0 #857;
+ * 契约 §G.7c / 附录 B.1 `mcpReconnect`;sdk 9.6.0 尚未声明端点与体,读口 duck-typed 注入,与 `sessionMemoryStatus` 同款)。
+ *
+ * ── 这一口答的是哪件事 ────────────────────────────────────────────────────────────────────
+ * 传输断了的 stdio MCP server 在不结束任务的前提下**重拨一台具名 server**:`POST /v1/sessions/:id/mcp/reconnect { server }`。
+ * 壳只有「重连这台」按钮与结果渲染;判定(三态分臂 / 名册在场性 / 失败分诊 / 交易文案)三端各写一遍必各错一遍 ⇒ 归包。
+ *
+ * ── 🔴 五条契约读法(§G.7c 逐字)──────────────────────────────────────────────────────────
+ *  ① `outcome` 是**唯一判别键**,三态全部走 200:`accepted`(core reconnected)/ `refused`(core refused **或** not_declared,
+ *     wire 上刻意不可区分,子理由骑 `reason`)/ `unsupported`(server 自己的词:这条 run 一台 MCP 都没声明;不是 409、不是 refused)。
+ *  ② `unsupported` **恒五键**(taskId / sessionId / server / outcome / reason):那条臂没有 core 结果,`prefix` / `toolCount` / `added` /
+ *     `removed` 编成 `0` / `[]` = 替 core 说一句它没说过的话 ⇒ 本读器**按 outcome 分支再读**;accepted / refused 四座缺一 ⇒ 整只畸形。
+ *  ③ **名册按 `toolNames` 的在场性**:在场非空 = 对该 `prefix` 域断言的名册(**超集**:core 挂载前还滤一道);在场 `[]` = 拨号失败、
+ *     这台的工具被撤走(空数组是一句话);整键缺席 = 这条臂从未碰过连接,挂载名册原样不动。真挂上了什么读 `wiring_manifest.tools`。
+ *  ④ **下一步动作读 `status.errorCode` / `httpStatus`,不解析 `reason`**:`errorCode` 是 core 十词闭集但 server 不枚举 ⇒ 本读器按**开集**
+ *     透传(消费端 switch 必带 default);`delivered` 三词 / `transportClosed` 在场即 true(缺席 = 没观察到关闭,**不是**还活着);
+ *     `error` / `serverInfo` / `reason` 是远端自由文本 —— UNTRUSTED-for-display,呈前消毒封长。
+ *  ⑤ **交易,不是刷新**(core 原话,契约 🔴 必进 UI):旧连接在拨新号**之前**就被关 ⇒ 一次失败的重拨花掉一条能用的连接。
+ *     壳不许只写「重连」—— 措辞单源 {@link MCP_RECONNECT_TRANSACTION_NOTICE}。
+ *
+ * ── 失败分诊按 `errorCode` 不按 status(与 `classifyMemoryStatusFailure` 同律)────────────────
+ *  422 `steering.invalid_content` ⇒ invalid · 409 `steering.not_running` ⇒ not_running(parked / 终态 / 他副本 / 无活流四臂一码)·
+ *  501 `capability.run_store_required` ⇒ unsupported/capability · 404 `not_found.route` ⇒ unsupported/route(老 server 无此路由)·
+ *  404 `not_found.session` ⇒ not_found(未知 / 非属主同码同串)· 无码 ⇒ failed(**不猜**)。
+ */
+import { capForDisplay } from './fleetTaskDesc.js';
+/** `outcome` 三词(契约 §G.7c;`unsupported` 是 server 的词,core 没有它)。 */
+export const MCP_RECONNECT_OUTCOMES = Object.freeze(['accepted', 'refused', 'unsupported']);
+/**
+ * 「重连 = 一次交易」的**唯一措辞铸点**(三端共用;契约 🔴 这句必须进 UI,壳不许只写「重连」)。
+ * 零内部车道词;只说用户能据以决策的事实:旧连接先关、失败则工具撤走、直到再拨成功。
+ */
+export const MCP_RECONNECT_TRANSACTION_NOTICE = 'Reconnecting closes the current connection before dialing again. On a healthy server this is a transaction, ' +
+    'not a refresh: a failed re-dial leaves the server down and withdraws its tools from the model until a later re-dial succeeds.';
+const RECONNECT_TEXT_MAX = 200;
+const RECONNECT_WORD_MAX = 40;
+/** 契约 §G.7c:`server` 非空且 ≤ 190 字符(逐字进 core 运维通告 `detail.server`)。 */
+const SERVER_NAME_MAX = 190;
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const nonEmpty = (v) => typeof v === 'string' && v.length > 0;
+const stringList = (v) => Array.isArray(v) && v.every((t) => typeof t === 'string') ? [...v] : undefined;
+function projectStatus(raw) {
+    if (!isRecord(raw) || !nonEmpty(raw.name) || !nonEmpty(raw.status))
+        return undefined;
+    // `name` 是**身份键**(core `statuses[name]` 的键,与顶层 `server` 同一事实),不是远端自由文本 ⇒ 原样,不封长(opus 替补复审 [low]);
+    // 消毒封长只给 serverInfo / error 两座远端文本。
+    const view = { name: raw.name, status: raw.status };
+    if (nonEmpty(raw.errorCode))
+        view.errorCode = raw.errorCode;
+    if (typeof raw.httpStatus === 'number' && Number.isInteger(raw.httpStatus))
+        view.httpStatus = raw.httpStatus;
+    if (nonEmpty(raw.delivered))
+        view.delivered = raw.delivered;
+    const si = raw.serverInfo;
+    if (isRecord(si) && typeof si.name === 'string' && typeof si.version === 'string') {
+        view.serverInfo = { name: capForDisplay(si.name, RECONNECT_WORD_MAX), version: capForDisplay(si.version, RECONNECT_WORD_MAX) };
+    }
+    if (typeof raw.error === 'string')
+        view.error = capForDisplay(raw.error, RECONNECT_TEXT_MAX);
+    if (raw.transportClosed === true)
+        view.transportClosed = true;
+    return view;
+}
+function projectListingIncomplete(raw) {
+    // `reason` / `pages` 必填(server 侧无条件投 pages):缺一 = 读不懂这一格,由调用方判整只畸形(在场但坏形 ≠ 缺席)。
+    if (!isRecord(raw) || !nonEmpty(raw.reason))
+        return undefined;
+    if (typeof raw.pages !== 'number' || !Number.isInteger(raw.pages) || raw.pages < 0)
+        return undefined;
+    const view = { reason: raw.reason, pages: raw.pages };
+    if (typeof raw.budgetMs === 'number' && Number.isFinite(raw.budgetMs))
+        view.budgetMs = raw.budgetMs;
+    if (typeof raw.error === 'string')
+        view.error = capForDisplay(raw.error, RECONNECT_TEXT_MAX);
+    return view;
+}
+/**
+ * 200 体 → 读视图;**畸形一律 `undefined`**(不编、不猜)。按 `outcome` 分形读键(文件头 ①②③④)。
+ */
+export function projectMcpReconnectResult(body) {
+    if (!isRecord(body))
+        return undefined;
+    if (!nonEmpty(body.taskId) || !nonEmpty(body.sessionId) || !nonEmpty(body.server))
+        return undefined;
+    const outcome = body.outcome;
+    if (typeof outcome !== 'string' || !MCP_RECONNECT_OUTCOMES.includes(outcome))
+        return undefined;
+    const base = { taskId: body.taskId, sessionId: body.sessionId, server: body.server };
+    if (outcome === 'unsupported') {
+        // 恒五键:其余键真出现了也不过境。`reason` 是人读文本(server 侧可为空)—— `outcome` 才是唯一判别键,
+        // 一句人读文本不许把判别键整只报废(opus 替补复审 [low]):缺席 / 空串 ⇒ 视图无 reason 键。
+        const u = { outcome: 'unsupported', ...base };
+        if (nonEmpty(body.reason))
+            u.reason = capForDisplay(body.reason, RECONNECT_TEXT_MAX);
+        return u;
+    }
+    // accepted / refused:四座必填(core 型上必填,server 原样投),缺一整只畸形。
+    const added = stringList(body.added);
+    const removed = stringList(body.removed);
+    if (!nonEmpty(body.prefix) || typeof body.toolCount !== 'number' || !Number.isInteger(body.toolCount) || body.toolCount < 0)
+        return undefined;
+    if (added === undefined || removed === undefined)
+        return undefined;
+    const view = {
+        outcome: outcome,
+        ...base,
+        prefix: body.prefix,
+        toolCount: body.toolCount,
+        added,
+        removed,
+    };
+    // 🔴 「在场但坏形」≠「缺席」(opus 替补复审 [medium]×2):`toolNames` 缺席 = 名册别动、`listingIncomplete` 缺席 = 名册走完了,
+    //    两者在契约上都是**正面指令**;把读不懂的那一格折成缺席 = 替 server 下一条它没下的指令 ⇒ 在场但坏形一律整只畸形。
+    if ('toolNames' in body && body.toolNames !== undefined) {
+        const toolNames = stringList(body.toolNames);
+        if (toolNames === undefined)
+            return undefined;
+        view.toolNames = toolNames;
+    }
+    if (nonEmpty(body.reason))
+        view.reason = capForDisplay(body.reason, RECONNECT_TEXT_MAX);
+    const status = projectStatus(body.status);
+    if (status !== undefined)
+        view.status = status;
+    if ('listingIncomplete' in body && body.listingIncomplete !== undefined) {
+        const li = projectListingIncomplete(body.listingIncomplete);
+        if (li === undefined)
+            return undefined;
+        view.listingIncomplete = li;
+    }
+    return view;
+}
+/** 抛出物 → 判决(按 `errorCode`;与 `classifyMemoryStatusFailure` 同律:无码不猜)。 */
+export function classifyMcpReconnectFailure(e) {
+    // 🔴 读 `errorCode` 本身包在 try 里(异源对抗复审 [medium]):拒因可以是 Proxy / 带抛 getter 的对象,读一个属性就抛 ⇒
+    //    分诊器抛穿「永不抛」。读不出 = 判不出码 ⇒ failed,原拒因原样带出。
+    let code;
+    try {
+        code = typeof e === 'object' && e !== null ? e.errorCode : undefined;
+    }
+    catch {
+        return { kind: 'failed', error: e };
+    }
+    if (code === 'steering.invalid_content')
+        return { kind: 'invalid' };
+    if (code === 'steering.not_running')
+        return { kind: 'not_running' };
+    // 501 两码并列(附录 B.1:缺 sessionStorage.ownerOf ⇒ `capability.session_ownership_required`,缺 run 账面 ⇒ `capability.run_store_required`)
+    // ⇒ 前缀族开集(opus 替补复审 [medium]);`feature.*` = 面在但开关关着,与 capability 分列(与 memory-status 分诊同律)。
+    if (typeof code === 'string' && code.startsWith('capability.'))
+        return { kind: 'unsupported', reason: 'capability' };
+    if (typeof code === 'string' && code.startsWith('feature.'))
+        return { kind: 'unsupported', reason: 'feature' };
+    if (code === 'not_found.route')
+        return { kind: 'unsupported', reason: 'route' };
+    if (code === 'not_found.session')
+        return { kind: 'not_found' };
+    return { kind: 'failed', error: e };
+}
+/**
+ * 「重连这台 MCP」的消费口:**永不抛**。本地先按契约把体门(`server` 非空 ≤ 190)判掉,不发一条注定 400 的请求;
+ * 回体经 {@link projectMcpReconnectResult} 投影;**回声身份**(`sessionId` / `server`)与请求逐字相等,否则 `failed`(宁缺席不串台,
+ * 与 `readSessionMemoryStatus` 同律)。注入口没有方法 ⇒ `unsupported/route`(壳没接线 = 面不存在)。
+ */
+export async function reconnectMcpServer(client, sessionId, server, opts) {
+    if (!nonEmpty(sessionId))
+        return { kind: 'invalid' };
+    if (!nonEmpty(server) || server.length > SERVER_NAME_MAX)
+        return { kind: 'invalid' };
+    try {
+        const verb = client?.sessions?.mcpReconnect;
+        if (typeof verb !== 'function')
+            return { kind: 'unsupported', reason: 'route' };
+        // 🔴 本地取消闸(异源复审第二轮 [medium]):signal 只转交给注入口不够 —— 壳的传输若忽略它,用户已撤销的操作仍会关掉一条
+        //    健康连接并重拨(失败则工具撤走)。破坏性动词在「用户说停」之后一发都不许出。
+        if (opts?.signal?.aborted === true) {
+            return { kind: 'failed', error: opts.signal.reason ?? new Error('mcpReconnect: aborted before the verb was called') };
+        }
+        // 方法形调用保接收者(真 SDK 资源方法体走 this.t.request)。
+        const raw = await client.sessions.mcpReconnect(sessionId, { server }, opts?.signal ? { signal: opts.signal } : undefined);
+        const view = projectMcpReconnectResult(raw);
+        if (view === undefined)
+            return { kind: 'failed', error: new Error('mcpReconnect: malformed body') };
+        if (view.sessionId !== sessionId || view.server !== server)
+            return { kind: 'failed', error: new Error('mcpReconnect: response identity mismatch') };
+        return { kind: 'ok', result: view };
+    }
+    catch (e) {
+        return classifyMcpReconnectFailure(e);
+    }
+}
+/**
+ * 能力位 `GET /v1/capabilities.mcpReconnect`(设施依赖 = runStore ∧ sessionStorage.ownerOf)的三态读:
+ * `available` / `unavailable` / `not_reported`(键缺席 = 老 server <7.85.0 **判不了**,不折 unavailable);坏形 ⇒ `undefined`。
+ * 纯投影(caps 体由宿主交,本包不另开 tee:这一位只在按钮亮不亮时读一次)。
+ */
+export function projectMcpReconnectCapability(caps) {
+    if (!isRecord(caps))
+        return undefined;
+    if (!('mcpReconnect' in caps) || caps.mcpReconnect === undefined)
+        return 'not_reported';
+    if (caps.mcpReconnect === true)
+        return 'available';
+    if (caps.mcpReconnect === false)
+        return 'unavailable';
+    return undefined;
+}
+/**
+ * 三态 → 一句结果(**唯一措辞铸点**;三端共用;零内部车道词)。`accepted` 带工具计数;`refused` 说清工具已撤走(交易的代价)并带 reason;
+ * `unsupported` 说清是这条 run 的装配(未声明 MCP),不是 refused。
+ */
+export function mcpReconnectOutcomeDetail(view) {
+    const name = capForDisplay(view.server, RECONNECT_WORD_MAX);
+    switch (view.outcome) {
+        case 'accepted':
+            return `MCP server ${name} was re-dialed: ${view.toolCount} tool${view.toolCount === 1 ? '' : 's'} mounted (${view.added.length} added, ${view.removed.length} removed)`;
+        case 'refused': {
+            // 🔴 名册按 toolNames 在场性分三句(异源对抗复审 [medium]:此前无条件说「工具已撤走」,把未知名 / 重拨在飞 / 已撤销这些
+            //    **没碰连接**的拒绝也说成撤了工具,误导用户再来一次破坏性重拨):
+            //    缺席 = 这条臂从未碰过连接,名册未动;[] = 拨号失败,工具撤走;非空 = 拒了但对该 prefix 域做了名册断言,如实报数。
+            const why = view.reason !== undefined ? ` — ${view.reason}` : '';
+            if (view.toolNames === undefined) {
+                return `MCP server ${name} was NOT re-dialed; its connection and tools were left untouched${why}`;
+            }
+            if (view.toolNames.length === 0) {
+                return `MCP server ${name} was NOT re-dialed and its tools were withdrawn from the model until a later re-dial succeeds${why}`;
+            }
+            return `MCP server ${name} was NOT re-dialed; the engine reports ${view.toolNames.length} tool${view.toolNames.length === 1 ? '' : 's'} for it after this attempt${why}`;
+        }
+        case 'unsupported':
+            return (`This run declared no MCP servers, so there is nothing to re-dial (${name} is not part of this run)` +
+                (view.reason !== undefined ? ` — ${view.reason}` : ''));
+    }
+}

package/dist/request/taskRequest.d.ts

@@ -96,6 +96,11 @@ export interface TaskRequestInput {
      * 一个 400 回来。JS 调用方(本包是发出去的 npm 公开面)绕过型面时由构造器再判一次值。
      */
     memoryCapture?: 'off';
+    /**
+     * 「这一次别给我记忆」的**请求级整面关**(CC-39③;server §12.7 姊妹键)。单成员闭集 `'off'`,缺席 = 记忆照常挂。
+     * 型面同 {@link TaskRequestInput.memoryCapture}:给它一个宽串型等于邀请调用方发一个 400 回来;JS 调用方由构造器再判一次值。
+     */
+    memory?: 'off';
     /** rewind 三件(E18);端自己判空。 */
     rewind?: Record<string, unknown>;
     /** 仓库坐标串(scan/code-review 场景;今日唯一供给方 web 的 Repository 输入=url/`owner/name` 串。
@@ -172,6 +177,31 @@ export declare const MEMORY_CAPTURE_OFF: "off";
 export declare function memoryCaptureDeclarationField(declared: boolean): {
     memoryCapture: 'off';
 } | Record<string, never>;
+/** `memory: "off"` 的唯一字面(server §12.7;core #863 W3)。 */
+export declare const MEMORY_OFF: "off";
+/**
+ * 「这一次别给我记忆」的**意图位** → 提交腿的 spread-ready 片段(CC-39③,0.72.8;与 {@link memoryCaptureDeclarationField} 同律)。
+ * 🔴 `false` ⇒ 整键缺席(= 记忆照常挂的唯一写法),不是 `{ memory: undefined }`、更不是某个「on」值。
+ * 🔴 本层只答「下一条提交带不带这一键」,不答「这次真的没挂记忆面」:后者只有引擎知道(老 server 400 / 更老 worker 静默忽略);
+ *    终局 memory 状态词 `disabled`(不是 `no-spec`)才是引擎的答案,端别拿这一位去渲「已关」。
+ * 🔴 两键同发(`memoryCapture:"off"` + `memory:"off"`)时 capture 的单向记录**不落**(core 只在挂引擎时记)—— 契约 §12.7 写真话,
+ *    不许拿 `memory:"off"` 当隐私声明;要「别记住我」用 memoryCapture 那一键。
+ */
+export declare function memoryOffDeclarationField(declared: boolean): {
+    memory: 'off';
+} | Record<string, never>;
+/**
+ * 端的两个入口 → 「这一次别给我记忆」的**意图位**(cli [7510]:发口投影归包,三端同判、壳零自判)。
+ *   · `flag`:CLI 旗 `--memory <word>` 的原词 —— **只认恰 `'off'`**(单成员闭集;`'on'` / 大小写 / 带空格一律不认,
+ *     那些拼法上 wire 会被 server 400,而本层不替它买路也不替它编);
+ *   · `settingsMemory`:settings 的 CC 形 `memory` 段 —— **只认严格 `{ enabled: false }`**(`"false"` / `0` / 缺席 = 沉默不是关,
+ *     与 core `ParentSpecSeat.memoryOff` 只从显式 `enabled: false` 铸同律)。
+ * 任一成立 ⇒ `true`;其余 / 坏形 / 非对象入参 ⇒ `false`(= 键缺席,记忆照常挂)。喂给 {@link memoryOffDeclarationField}。
+ */
+export declare function memoryOffDeclared(input: {
+    flag?: unknown;
+    settingsMemory?: unknown;
+} | null | undefined): boolean;
 export declare function buildTaskRequest(input: TaskRequestInput, lane: RequestLane): TaskRequestLike;
 /** `applyLiveRequestDefaults` 的宿主输入(端解析好的值,同样零取值方式)。 */
 export interface LiveDefaultsInput {

package/dist/request/taskRequest.js

@@ -51,6 +51,12 @@ export const REQUEST_FIELD_MATRIX = [
     //    在飞的 run,本键管「本会话的下一次新提交」。非 live 的 verb(parked / 终态 / 他副本)回
     //    409 `steering.not_running` 并**指路本键** —— 端没有本键就接不住那条指路。
     { field: 'memoryCapture', lanes: ['interactive', 'print'], live: true, why: '本会话永远不进长期记忆的**声明形**(server §12.4 body 键,单成员闭集 "off");两条车道都是提交面 ⇒ 都能声明。与 memoryWrite:false 不是一个轴(那是「本 run 只读平面」)。⚠️ parked 续跑腿结构性拿不到声明(决策/续跑端点从持久 body 重建 spec),那是引擎侧事实,不是本层的漏' },
+    // ── memory:"off"(CC-39③,0.72.8;server 7.84.0 S-405 / core #863 W3)────────────────────────
+    // 🔴 契约 §12.7 姊妹键:`memoryCapture` = 「记忆照常用,但别记住我」(会话级采集面关,一次性);`memory` =
+    //    「这一次别给我记忆」(请求级整面关:不挂 # Memory 段 / 索引 / 三只记忆工具 / 写准入;零记录,可逐请求开关)。
+    //    同形、不同轴、可并存;两键共用同一只拼写判据(400 `request.field_invalid` 两腿同句)。缺席 = 记忆照常挂。
+    //    无能力位(7.78.1–7.83.x 只能 trial-by-400)⇒ 本层不预判 server 版本,照发。子代地板(ParentSpecSeat.memoryOff)归 core。
+    { field: 'memory', lanes: ['interactive', 'print'], live: true, why: '这一次运行不挂记忆面的**请求级**开关(server §12.7 body 键,单成员闭集 "off");两条车道都是提交面 ⇒ 都能声明。与 memoryCapture(采集面)不是一个轴、可并存;与 memoryWrite:false(只读平面)也不是一个轴' },
     // ── print 独有(§8-5 认定的**有理由**的差异)──────────────────────────────────────────────
     { field: 'finalVerification', lanes: ['print'], live: true, why: 'P1-1 终验:无人值守车道才需要引擎自证;交互 REPL 由人当场看结果。#106 裁 B(让位+告知)后交互面默认关' },
     { field: 'limits', lanes: ['print'], live: true, why: 'P2-3-b:`-p` 的预算护栏(--max-* flag 族),交互 REPL 由人随时 Esc' },
@@ -122,6 +128,13 @@ const PERMISSION_FACE_KEY = 'permissions';
  * `toString` 与 `constructor` 都抛错,而**构造错误文本时抛错**会把「拒」这个判决换成一个面目全非的
  * 异常。判决是拒,描述只是线索,取不到就报 unreadable。
  */
+/**
+ * 拒绝文本用的**粗分类**(0.72.8 异源复审第二轮 [medium] 真修):只用 `typeof` / null / array 三个固定词,**不**读
+ * `Symbol.toStringTag`、也不读 prototype 的 constructor 名 —— 那两样都是**调用方可控**的串,对象可以借它们把敏感内容
+ * 带进错误展示 / 日志。memory 一族(隐私 / 记忆面声明)的拒绝路径一律走它;`shapeTag` 留给 settings.resolved 那类
+ * 载体形诊断(那里报的是构造器名这一线索,与本族的「只报形状不回显值」纪律不同)。
+ */
+const coarseShape = (v) => v === null ? 'typeof=object / null' : Array.isArray(v) ? 'typeof=object / array' : `typeof=${typeof v}`;
 const shapeTag = (v) => {
     try {
         const proto = Object.getPrototypeOf(v);
@@ -447,13 +460,69 @@ export const MEMORY_CAPTURE_OFF = 'off';
 export function memoryCaptureDeclarationField(declared) {
     return declared ? { memoryCapture: MEMORY_CAPTURE_OFF } : {};
 }
+/** `memory: "off"` 的唯一字面(server §12.7;core #863 W3)。 */
+export const MEMORY_OFF = 'off';
+/**
+ * 「这一次别给我记忆」的**意图位** → 提交腿的 spread-ready 片段(CC-39③,0.72.8;与 {@link memoryCaptureDeclarationField} 同律)。
+ * 🔴 `false` ⇒ 整键缺席(= 记忆照常挂的唯一写法),不是 `{ memory: undefined }`、更不是某个「on」值。
+ * 🔴 本层只答「下一条提交带不带这一键」,不答「这次真的没挂记忆面」:后者只有引擎知道(老 server 400 / 更老 worker 静默忽略);
+ *    终局 memory 状态词 `disabled`(不是 `no-spec`)才是引擎的答案,端别拿这一位去渲「已关」。
+ * 🔴 两键同发(`memoryCapture:"off"` + `memory:"off"`)时 capture 的单向记录**不落**(core 只在挂引擎时记)—— 契约 §12.7 写真话,
+ *    不许拿 `memory:"off"` 当隐私声明;要「别记住我」用 memoryCapture 那一键。
+ */
+export function memoryOffDeclarationField(declared) {
+    return declared ? { memory: MEMORY_OFF } : {};
+}
+/**
+ * 端的两个入口 → 「这一次别给我记忆」的**意图位**(cli [7510]:发口投影归包,三端同判、壳零自判)。
+ *   · `flag`:CLI 旗 `--memory <word>` 的原词 —— **只认恰 `'off'`**(单成员闭集;`'on'` / 大小写 / 带空格一律不认,
+ *     那些拼法上 wire 会被 server 400,而本层不替它买路也不替它编);
+ *   · `settingsMemory`:settings 的 CC 形 `memory` 段 —— **只认严格 `{ enabled: false }`**(`"false"` / `0` / 缺席 = 沉默不是关,
+ *     与 core `ParentSpecSeat.memoryOff` 只从显式 `enabled: false` 铸同律)。
+ * 任一成立 ⇒ `true`;其余 / 坏形 / 非对象入参 ⇒ `false`(= 键缺席,记忆照常挂)。喂给 {@link memoryOffDeclarationField}。
+ */
+export function memoryOffDeclared(input) {
+    if (typeof input !== 'object' || input === null)
+        return false;
+    // 🔴 异源对抗复审 [medium] 真修:入口投影**不许**把打错字的收紧声明降级成「缺席」—— 那样片段函数删键、`refuseBadMemoryOff`
+    //    无从校验,用户以为关了、这次运行照常挂上记忆面。旗在场但不是 'off' ⇒ 响亮拒(与 buildTaskRequest 同律,不回显值)。
+    const flag = input.flag;
+    if (flag !== undefined && flag !== null && flag !== MEMORY_OFF) {
+        throw new TypeError(`memoryOffDeclared: --memory 旗只接受字面量 \'off\' 或缺席 —— 收到 ${coarseShape(flag)}。上游是单成员闭集(没有 "on"),` +
+            '打错字的关闭声明若被折成缺席,这一次运行会照常挂上记忆面而声明人不会知道。错误文本只报形状,不回显值。');
+    }
+    let fromSettings = false;
+    const sm = input.settingsMemory;
+    if (sm !== undefined && sm !== null) {
+        if (typeof sm !== 'object' || Array.isArray(sm)) {
+            throw new TypeError(`memoryOffDeclared: settings 的 memory 段必须是对象 —— 收到 ${coarseShape(sm)}。`);
+        }
+        const enabled = sm.enabled;
+        // CC 形 `memory: { enabled }`:缺席 = 沉默(不是关);在场必须是布尔 —— "false" / 0 是打错字的收紧声明,同样响亮拒。
+        if (enabled !== undefined && typeof enabled !== 'boolean') {
+            throw new TypeError(`memoryOffDeclared: settings memory.enabled 在场时必须是布尔 —— 收到 ${coarseShape(enabled)}。`);
+        }
+        fromSettings = enabled === false;
+    }
+    return flag === MEMORY_OFF || fromSettings;
+}
+const refuseBadMemoryOff = (v) => {
+    if (v === undefined || v === null)
+        return;
+    if (v === 'off')
+        return;
+    throw new TypeError('buildTaskRequest: memory 只接受字面量 `\'off\'` 或缺席(undefined/null)—— ' +
+        `收到 ${coarseShape(v)}。这一位是**请求级整面开关**(「这一次别给我记忆」),上游是**单成员闭集**(没有 ` +
+        '`"on"`,`{ enabled: false }` 对象形也不是 wire 拼法)且对坏拼写**响亮拒**(server 400 `request.field_invalid`)。' +
+        '本层若静默删键,这一次运行会照常挂上记忆面而声明人不会知道 —— 与 memoryCapture 同一条纪律。错误文本只报形状,不回显值。');
+};
 const refuseBadMemoryCapture = (v) => {
     if (v === undefined || v === null)
         return;
     if (v === 'off')
         return;
     throw new TypeError('buildTaskRequest: memoryCapture 只接受字面量 `\'off\'` 或缺席(undefined/null)—— ' +
-        `收到 ${shapeTag(v)}。这一位是**会话级隐私声明**(「本会话永远不进长期记忆」),` +
+        `收到 ${coarseShape(v)}。这一位是**会话级隐私声明**(「本会话永远不进长期记忆」),` +
         '上游是**单成员闭集**(没有 `"on"`)且对坏拼写**响亮拒**(core `config.memory_capture_spelling` / ' +
         'server 400 `request.field_invalid`)。本层若把坏值静默删键,请求会照发、引擎会照常采集,' +
         '而声明人不会知道自己的 opt-out 丢了 —— 把一条隐私请求按打字错误静默丢掉是**禁的方向**。' +
@@ -462,7 +531,12 @@ const refuseBadMemoryCapture = (v) => {
 export function buildTaskRequest(input, lane) {
     const live = input.live;
     // ⑤ 响亮拒排在最前面:一条打错字的隐私声明绝不许被后面任何一条「不 stamp」路径吞掉。
-    refuseBadMemoryCapture(input.memoryCapture);
+    // 🔴 只读一次(异源复审第二轮 [medium] 真修):校验与 stamp 共用**同一次读取**。带 getter / proxy 的入参在两次读取之间可以
+    //    变值 —— 第一次 'off' 过了校验、第二次 'OFF' 在 stamp 处被折成缺席,一条收紧声明就这样静默丢了。
+    const memoryCaptureIn = input.memoryCapture;
+    const memoryIn = input.memory;
+    refuseBadMemoryCapture(memoryCaptureIn);
+    refuseBadMemoryOff(memoryIn);
     /** stamp 门:字段在本车道的表里 ∧(非 live-gated ∨ 本次是 live 车道)∧ 值非空。 */
     const on = (field, value) => {
         if (value === undefined || value === null)
@@ -541,9 +615,11 @@ export function buildTaskRequest(input, lane) {
             : {}),
         ...(on('oneShot', input.oneShot) && input.oneShot === true ? { oneShot: true } : {}),
         // ⑤ 单成员闭集:值**恰是** `'off'` 才 stamp。表外拼写在上面已经**响亮拒**(见 `refuseBadMemoryCapture`)。
-        ...(on('memoryCapture', input.memoryCapture) && input.memoryCapture === 'off'
+        ...(on('memoryCapture', memoryCaptureIn) && memoryCaptureIn === 'off'
             ? { memoryCapture: 'off' }
             : {}),
+        // CC-39③:姊妹键同律(值恰是 'off' 才 stamp;坏拼写已在上面响亮拒)。
+        ...(on('memory', memoryIn) && memoryIn === 'off' ? { memory: 'off' } : {}),
         ...(Object.keys(settingsOut).length > 0 ? { settings: settingsOut } : {}),
     };
     return out;

package/dist/resumeRefusalCopy.d.ts

@@ -153,7 +153,7 @@ export declare function resumeContextUnavailableFromError(err: unknown): ResumeC
  * 🔴 **只凭码不推断原因**(异源对抗复审实抓):server 在「上下文被回收」与「上下文读取失败(如存储故障)」两种情况下
  *    都返回本码,wire 上没有判别位 ⇒ 第一句只说「当前没有可用的上下文来继续它」,不说「等得太久 / 已被回收」。
  * 🔴 **调大保留时长救不回这一次**(上下文已删就是删了),它只能避免以后再发生 ⇒ 第三句按 `runId` 在场与否给恢复指引,
- *    保留时长只作预防句。零内部车道词;不铸秒数(保留时长由端按 {@link ResumeContextUnavailableDetail.staleAfterSec}
- *    单独渲,缺席就不渲)。
+ *    保留时长只作预防句。零内部车道词;{@link ResumeContextUnavailableDetail.staleAfterSec} 在场时第三句**带原数**
+ *    (0.72.9 CC-45:此前留给端渲而端没渲 ⇒ 有数必渲),缺席就不渲、不编。
  */
 export declare function resumeContextUnavailableContent(d: ResumeContextUnavailableDetail): string;

package/dist/resumeRefusalCopy.js

@@ -185,13 +185,19 @@ export function resumeContextUnavailableFromError(err) {
  * 🔴 **只凭码不推断原因**(异源对抗复审实抓):server 在「上下文被回收」与「上下文读取失败(如存储故障)」两种情况下
  *    都返回本码,wire 上没有判别位 ⇒ 第一句只说「当前没有可用的上下文来继续它」,不说「等得太久 / 已被回收」。
  * 🔴 **调大保留时长救不回这一次**(上下文已删就是删了),它只能避免以后再发生 ⇒ 第三句按 `runId` 在场与否给恢复指引,
- *    保留时长只作预防句。零内部车道词;不铸秒数(保留时长由端按 {@link ResumeContextUnavailableDetail.staleAfterSec}
- *    单独渲,缺席就不渲)。
+ *    保留时长只作预防句。零内部车道词;{@link ResumeContextUnavailableDetail.staleAfterSec} 在场时第三句**带原数**
+ *    (0.72.9 CC-45:此前留给端渲而端没渲 ⇒ 有数必渲),缺席就不渲、不编。
  */
 export function resumeContextUnavailableContent(d) {
-    const third = d.runId !== undefined
+    // 0.72.9 CC-45(cli L-383 / test [7516] N-G10):**有数必渲、无数不编**。0.72.1 曾把秒数留给端「单独渲」而端没渲 ⇒ 补充句永无
+    //    保留秒数;归层改为本句直接带原数(整数秒,读口已窄读),缺席时本句逐字同 0.72.1。
+    //    🔴 措辞铸点是最后一关(opus 替补复审 [low]):公面函数入参可被手工构造,`0` / 非整数 / 巨数与读口同一判据(整数 ∧ ≥1)才渲,
+    //    否则不渲 —— 绝不渲「0 秒」这种看起来像答案的空壳。
+    const sec = d.staleAfterSec;
+    const retention = typeof sec === 'number' && Number.isSafeInteger(sec) && sec >= 1 ? `(本部署的会话保留时长为 ${sec} 秒)` : '';
+    const third = (d.runId !== undefined
         ? '错误里带了这条运行的 id,请用它自己恢复这条运行再决;调大会话保留时长只能避免以后再发生,救不回这一次'
-        : '错误里没有带运行 id,请回到运行列表找到这条运行自己恢复它再决;调大会话保留时长只能避免以后再发生,救不回这一次';
+        : '错误里没有带运行 id,请回到运行列表找到这条运行自己恢复它再决;调大会话保留时长只能避免以后再发生,救不回这一次') + retention;
     return [
         '这个批准无处投递:发起这次运行的会话当前没有可用的上下文来继续它',
         '什么都没有被决定,你的决定没有被消费,这张卡仍在等待',

package/dist/sessionMemoryStatus.d.ts

@@ -29,12 +29,20 @@ export interface MemoryStatusClientLike {
         } & SessionMemoryStatus>;
     };
 }
+/**
+ * 读数体 = sdk 五键 + server 7.85.0 S-403 新键 `autoConsolidationArmed`(0.72.9 CC-39②;core #863 W1 唯一读法
+ * `autoRunOnRecommendationEffective` 组,与 manifest `autoConsolidation` 段在场性同源)。sdk 9.6.0 尚未声明 ⇒ 本包按结构读;
+ * 缺席 = 老 server(<7.85.0)**判不了**,不折 false —— 读法见 {@link readAutoConsolidationArmed}。
+ */
+export type MemoryStatusFacts = SessionMemoryStatus & {
+    readonly autoConsolidationArmed?: boolean;
+};
 export type MemoryStatusVerdict = 
 /** 200:读到了。`facts` 的**每一键**都按 wire 原样(合形才在场),缺席语义见 {@link readCaptureOptOut} 等。 */
 {
     readonly kind: 'ok';
     readonly sessionId: string;
-    readonly facts: SessionMemoryStatus;
+    readonly facts: MemoryStatusFacts;
 }
 /** 本部署**没有这个面** —— 端应当**别提供这个入口**(不是报错,是诚实的能力缺席)。 */
  | {
@@ -136,3 +144,9 @@ export declare function readLastCapture(s: SessionMemoryStatus): LastCaptureRead
 export declare function readSessionMemoryStatus(client: MemoryStatusClientLike, sessionId: string, opts?: {
     signal?: AbortSignal;
 }): Promise<MemoryStatusVerdict>;
+/**
+ * 「这台部署的记忆自动整理武装了没有」:`armed` / `unarmed` / `indeterminate`。
+ * 🔴 缺席 = 老 server(<7.85.0)**判不了**,不折 `unarmed`;坏形同样 `indeterminate`(不抛)。三个词对运维是三条不同的下一步
+ * (与 manifest `autoConsolidation` 段「缺席 = indeterminate」同律;server 用 core 唯一读法组这一位,端别按席自判)。
+ */
+export declare function readAutoConsolidationArmed(facts: MemoryStatusFacts | null | undefined): 'armed' | 'unarmed' | 'indeterminate';

package/dist/sessionMemoryStatus.js

@@ -172,6 +172,8 @@ export async function readSessionMemoryStatus(client, sessionId, opts) {
                     ? { optOutSource: o.optOutSource }
                     : {}),
                 ...(typeof o.lastCaptureAt === 'number' ? { lastCaptureAt: o.lastCaptureAt } : {}),
+                // 0.72.9 CC-39②(server 7.85.0 S-403):布尔恒在场;非布尔 / 老 server 缺席 ⇒ 键不在场(不铸 false)。
+                ...(typeof o.autoConsolidationArmed === 'boolean' ? { autoConsolidationArmed: o.autoConsolidationArmed } : {}),
             },
         };
     }
@@ -179,3 +181,19 @@ export async function readSessionMemoryStatus(client, sessionId, opts) {
         return classifyMemoryStatusFailure(e);
     }
 }
+// ── ④ autoConsolidationArmed 三态(0.72.9 CC-39②)──────────────────────────────────────────
+/**
+ * 「这台部署的记忆自动整理武装了没有」:`armed` / `unarmed` / `indeterminate`。
+ * 🔴 缺席 = 老 server(<7.85.0)**判不了**,不折 `unarmed`;坏形同样 `indeterminate`(不抛)。三个词对运维是三条不同的下一步
+ * (与 manifest `autoConsolidation` 段「缺席 = indeterminate」同律;server 用 core 唯一读法组这一位,端别按席自判)。
+ */
+export function readAutoConsolidationArmed(facts) {
+    if (typeof facts !== 'object' || facts === null)
+        return 'indeterminate';
+    const v = facts.autoConsolidationArmed;
+    if (v === true)
+        return 'armed';
+    if (v === false)
+        return 'unarmed';
+    return 'indeterminate';
+}