@sema-agent/server 7.125.1 → 7.126.0

package/dist/brain.d.ts

@@ -108,8 +108,8 @@ export interface DegradeRouteWatch {
  *
  * 缺省下首字节段不铸键(core 自缺省当家,[ref])、`0` = 该段不设引擎钟;而切备只发生在一次调用**失败之后**。于是主网关接了连接
  * 却不回响应头时:缺省 ⇒ 要等 core 的首字节 lane 走完(缺省首窗 + 一次加宽重试;本仓不铸 `firstByteRetries`,S-753 车PA)才切备,
- * 时间预算短于那一段的调用在备网关被尝试之前就被取消 —— 以 core 7.33.x 缺省计 lane ≈ 15 min,code-review council 每个镜头的 180 s 与 team
- * discuss 的 600 s 都在其内(车PA codex r1:600 s 在主网关的加宽重试窗里到点,不是「只剩余量」);
+ * 时间预算短于那一段的调用在备网关被尝试之前就被取消 —— 以 core 7.33.x 缺省计 lane ≈ 15 min,一次带短时间预算的调用
+ * (分钟级的工具 / 子任务预算)在主网关的加宽重试窗里就到点,不是「只剩余量」;
  * `0` ⇒ 首字节 lane 永不切备。启动日志里同行的 `gatewayRetryCap:"fast-fail:…"` 只管共享重试梯子,读起来却像「会快切」—— 这条披露把它补齐。
  * 显式设了正数窗 ⇒ `undefined`(部署已表态);单路由 ⇒ `undefined`(没有备可切)。**不替运维铸窗**:出路是旋钮,不是本仓的数。
  */

package/dist/brain.js

@@ -193,7 +193,7 @@ export function buildFailoverFirstByteNotice(config) {
         firstByteTimeoutMs: r.firstByteTimeoutMs ?? null,
         effect: zero
             ? "the first-byte lane never fails over a primary that accepts the connection but sends no response headers (0 = no engine clock on that segment); only a run-level limit ends that wait"
-            : "a primary that accepts the connection but sends no response headers is failed over only after core's default first-byte lane runs out (the first window, then one widened retry); a call with a time budget shorter than that — the code-review council's 180 s lenses and team discuss's 600 s, with core 7.33.x defaults — is cancelled before the backup is ever tried",
+            : "a primary that accepts the connection but sends no response headers is failed over only after core's default first-byte lane runs out (the first window, then one widened retry); a call with a time budget shorter than that (minutes, with core 7.33.x defaults) is cancelled before the backup is ever tried",
         fix: "set MODEL_FIRST_BYTE_TIMEOUT_MS to the longest response-header wait a healthy primary needs (queue + prefill), so a hung primary is cut over after that window and its one widened retry",
     };
 }

package/dist/capabilities/builtin-tools.d.ts

@@ -27,7 +27,8 @@ export interface SubagentExtraToolOptions {
  *
  * core 7.46.0 #1432 —— **工厂与名册一个来源**:返回委派工具的两键,`extraTools`(每次 spawn 交出 `forSpawn` 选中的那几只)与
  * `extraToolNames`(全部可能交出的那几只的名字 / 别名 / 内容来源,从同一批 `ToolSpec` 读出)。名册在场 ⇒ 引擎重新能列出子代的工具池:
- * 定义级 / 工具级 / `TaskSpec.agents` 清单里的退役拼法与大小写孪生回到开跑前拒(`config.agent.unknown_tool`),记忆内容来源读者按声明读这几只。
+ * 定义级 / 工具级 / `TaskSpec.agents` 清单里没有任何工具答应的名字(core 7.49.0 #1623 起含无人挂的名;退役拼法与大小写孪生 7.46.0 起)开跑前拒
+ * (`config.agent.unknown_tool`),记忆内容来源读者按声明读这几只。
  * 修前(core 7.32.0–7.45.x)工厂恒在场 ⇒ 池不可静态知 ⇒ 那一族拼法只告不拒、委派结果一律按「外部」读。
  * 工厂**不抛**:各组的 `tools` 是装配期就建好的对象;部署 `forSpawn` 的抛由 core 收成「这一 spawn 什么都不继承 + 模型面披露句」(onExtraToolsError 记 warn)。
  * 一种拼法出现在两只工具上(部署工具与 `Now` 撞名 / 别名撞)⇒ core 在建委派工具处抛 `config.extra_tool_names`(`shape`),不静默取其一。

package/dist/capabilities/composite-members.d.ts

@@ -53,7 +53,7 @@ export declare const COMPOSITE_CAPABILITY_MEMBERS: {
     readonly retention: readonly ["mode", "maxAgeDays"];
     readonly workflowsGate: readonly ["engineCan", "denial"];
     readonly sealedKey: readonly ["alg", "publicKeyId", "publicKey"];
-    readonly workspaceSync: readonly ["persist", "keep"];
+    readonly workspaceSync: readonly ["persist", "keep", "timeoutMs", "cache"];
 };
 type CompositeTable = typeof COMPOSITE_CAPABILITY_MEMBERS;
 /** 值的**具名成员对象臂**(标量 / 字面词 / `false` / `null` / `undefined` / 数组 / 函数臂剥掉)。 */

package/dist/capabilities/composite-members.js

@@ -14,7 +14,7 @@ export const COMPOSITE_CAPABILITY_MEMBERS = {
     retention: ["mode", "maxAgeDays"],
     workflowsGate: ["engineCan", "denial"],
     sealedKey: ["alg", "publicKeyId", "publicKey"],
-    workspaceSync: ["persist", "keep"],
+    workspaceSync: ["persist", "keep", "timeoutMs", "cache"],
 };
 export function gateCompositeMembers(body) {
     return body;

package/dist/capabilities/hands-lane.d.ts

@@ -4,8 +4,8 @@
  * 根本问题(设计小票 §1,案源 [ref]/[ref]/[ref]):core 的手带工具面是 **per-Runner 表态**
  * (`prepare-task`:`handsEnabled = ownedEnv || deps.executionEnv`,ownedEnv 只要挂了
  * `executionEnvFactory` 就每任务必铸)。server 此前全场景共享一只 runner + 一只 subRunner,
- * 于是任何 REMOTE_EXEC 部署里,声明 clone-free 的 `scan`、只有 `run_council` 的评审团、
- * 零工具人格的 team 成员,最终 roster 都被并集进全量可写手带(Bash/Edit/Write/…)。
+ * 于是任何 REMOTE_EXEC 部署里,声明 clone-free 的 `scan` / `code-review`(当年还有评审团与讨论成员两种零工具人格),
+ * 最终 roster 都被并集进全量可写手带(Bash/Edit/Write/…)。
  *
  * 本模块提供三件:
  *  ① {@link ScenarioHands} 判别位 + {@link pickHandsRunner} 的**穷举** switch —— 新场景不表态 = 编译红,
@@ -19,14 +19,17 @@ import { type Runner, type TaskSpec, type ToolPolicy } from "@sema-agent/core";
 /** 场景对手带工具面的表态(闭集)。`full` = core 手带 band 照常 mount;`none` = 不挂 executionEnvFactory 的 Runner。 */
 export type ScenarioHands = "full" | "none";
 /**
- * 无手孪生 Runner 的 deps 构造:把 `executionEnvFactory` **摘键**(不是置 undefined)。
+ * 无手孪生 Runner 的 deps 构造:把 `executionEnvFactory` **与 `lspManager`** 一起**摘键**(不是置 undefined)。
  * 摘键让「这只 Runner 没有手」在 deps 字面量上自证;置 undefined 留下一个值为 undefined 的键,
  * 与 core 现在的 `deps.executionEnvFactory ||` 判读结果相同,但把正确性寄托在真值判断上。
+ * **无手就无 LSP**:LSP 管理器是手的附属(宿主车道的 `NodeLspManager` 经 `defaultLspReadText` 直读本地盘,
+ * 没有读面围栏;沙箱车道推断降级为 unavailable)—— 只摘手不摘它,无手 Runner 会在 StubExecutionEnv 上挂 LSP。
  */
-export declare function withoutExecutionEnv<T extends {
+export declare function withoutHands<T extends {
     executionEnvFactory?: unknown;
-}>(deps: T): Omit<T, "executionEnvFactory">;
-/** 一对 Runner:同 deps,唯一差别是 `handsless` 不挂 `executionEnvFactory`。 */
+    lspManager?: unknown;
+}>(deps: T): Omit<T, "executionEnvFactory" | "lspManager">;
+/** 一对 Runner:同 deps,唯一差别是 `handsless` 不挂 `executionEnvFactory` 与 `lspManager`。 */
 export interface HandsRunnerPair {
     full: Runner;
     handsless: Runner;

package/dist/capabilities/hands-lane.js

@@ -1,7 +1,7 @@
 import { handBandEffects, judgeRuleToolName, combinePolicies, createAllowDenyPolicy } from "@sema-agent/core";
 import { NO_DECLARED_TOOL_NAMES } from "../namespaced-rule-name.js";
-export function withoutExecutionEnv(deps) {
-    const { executionEnvFactory: _handsDropped, ...rest } = deps;
+export function withoutHands(deps) {
+    const { executionEnvFactory: _handsDropped, lspManager: _lspDropped, ...rest } = deps;
     return rest;
 }
 export function pickHandsRunner(hands, pair) {

package/dist/capabilities/memory-notice.d.ts

@@ -13,10 +13,11 @@
  * ⚠️ 两条边界,越界即双重注入/假话:
  *  · **engine 在场就不是我们的座位**。哪怕 `memoryWrite:false`(writeScope null)——那恰恰是引擎自己
  *    挂只读披露的状态,server 再叠一句口径不同的「你没有持久记忆」= 同一件事两种说法同框。
- *  · **推断到「有落盘路」就闭嘴**。判别式与 core 的 `rosterCanPersist` 同口径(已知落盘路 = 挂载且未
- *    排除的文件写工具 / 可写 shell)。⚠️ 名单确实要读(codex 复审 [medium] 之后加的 `excludeTools` 一位:
- *    roster 把落盘路**整批**卸掉时,手带在场也等于没有写通道),但负控仍然成立:必须**全部**已知落盘路
- *    都不在才算断链 —— `excludeTools:["Write"]` 不算(Bash/Edit 还在),请求面摘一个工具名改不动结论。
+ *  · **推断到「有落盘路」就闭嘴**。判别式与 core 的 `rosterCanPersist` 同口径(已知落盘路 = 这一 run 名册上
+ *    真挂着的文件写工具 / 可写 shell)。「名册上还剩什么」**只读引擎的答案**:core 7.49.0(#1623)起一 run 的可用工具是
+ *    引擎一只选择器(`allowTools` ∩ … − `excludeTools`,别名 / `Tool(content)` / `mcp__srv…` 都由它读)在 prepare 算出的,
+ *    本模块不再读请求的任何一张工具名表 —— 名册臂在装配时刻读 provider 拿到的 `ctx.tools`(选择器之后的名册)。
+ *    负控仍然成立:必须**全部**已知落盘路都不在名册上才算断链(摘掉 `Write`,Bash / Edit 还在)。
  */
 import { type PromptProvider, type ToolCatalogEntry } from "@sema-agent/core";
 import type { ScenarioHands } from "./hands-lane.js";
@@ -25,8 +26,8 @@ import { type ExecutionLane } from "../execution-lane-caps.js";
  * 「已知落盘路」的判据,作用在 core **静态工具目录**的一行上(S-503 / [ref])—— 与 core 自己的
  * `rosterCanPersist` 推断逐条同形,取的是同一批目录属性,不是它结论的抄件:
  *  · `mountedBy` 落在 core 的 `HANDS_BAND_TAGS` 里 —— 手带 band 之外的定义(记忆面工具、调度族)
- *    不在本判别式说得着的面上:本判别式的输入全是**手带事实**(`hands` / `handsReadOnly` /
- *    `excludeTools`),把一只 band 外的写工具算进来,就是拿一条根本没挂的通道去撤回披露(fail-open);
+ *    不在本判别式说得着的面上:本判别式的输入全是**手带事实**(`hands` / `handsReadOnly` / 名册上的手带名),
+ *    把一只 band 外的写工具算进来,就是拿一条根本没挂的通道去撤回披露(fail-open);
  *  · `face.effect !== "read"`(缺席读 `write`,与 core 同缺省)—— 只读 shell 壳在这里出局,它与全壳
  *    共用 `Bash` 这个 wire 名,靠的正是这一位分开;
  *  · `face.pathTarget.access !== "read"`(文件写工具)**或** `face.family === "shell"`(可写 shell)。
@@ -44,8 +45,8 @@ export declare function persistencePathToolNamesOf(entries: readonly ToolCatalog
  * 「已知落盘路」的工具名闭集 —— **由 core 的静态工具目录派生**,本仓不再存第二份名表
  * (S-503 / [ref];改前是手抄的四名表 Write / Edit / NotebookEdit / Bash,没有任何差集门)。
  *
- * 为什么手抄在这一位上特别危险:core 改名/加一只写工具,手抄表静默失配成「没有一个写工具被排除」
- * (fail-open 方向)—— `excludeTools` 把真正的落盘路全排掉了,而我们对着一张旧名单答「还剩」。
+ * 为什么手抄在这一位上特别危险:core 改名/加一只写工具,手抄表静默失配(fail-open 方向)—— 名册上真正的
+ * 落盘路已经全不在了,而我们对着一张旧名单答「还剩」。
  * 判据的属主现在是 {@link persistencePathToolNamesOf},值的属主是 core 的目录行。
  */
 export declare const KNOWN_PERSISTENCE_TOOL_NAMES: readonly string[];
@@ -69,15 +70,6 @@ export interface MemoryFaceFacts {
     hands: ScenarioHands;
     /** 折完 governance+settings 后的最终 `handsReadOnly`(`AUTONOMY=read-only` 收窄;plan 模式不点亮它 —— plan 的手带照挂、调用时由引擎问)。手带只剩读腿。 */
     handsReadOnly: boolean;
-    /** 折完之后的最终 `TaskSpec.excludeAllTools`(S-493;core 7.8.0 [ref])。`true` = **整只**工具面卸空
-     *  (core `prepareDeferClassify` 对它直接 `roster.unmountWhere(() => true)`)⇒ 手带在场也一条落盘路都不剩。
-     *  🔴 它与下面那张名单是**同一个语义面**(「哪些工具不在 roster 上」)的两种声明,判据合成一只
-     *  {@link isUnmounted} —— 上游同版的姊妹谓词 `fullShellReachable` 也正是把 `spec.excludeAllTools !== true`
-     *  当一个合取项(`prepare-inherited-gate.js` 亲读),本仓与它同口径。 */
-    excludeAllTools: boolean;
-    /** 折完之后的最终 `TaskSpec.excludeTools`(roster 真卸载,不是延迟披露)。**全部**已知落盘路都被排掉
-     *  ⇒ 手带在场也等于没有写通道 —— core 的 `rosterCanPersist` 也是按排除后的 roster 算的,这里跟上。 */
-    excludeTools: readonly string[] | undefined;
     /**
      * 本部署的手带**挂没挂**(= core 拿没拿到执行环境;能力表 `coreRemoteExecutionEnv` 位,经
      * {@link buildNoticeLaneFacts} 取)。`false` = `in-process`:core 落 `StubExecutionEnv`,手带整族不 mount
@@ -103,18 +95,31 @@ export interface MemoryFaceFacts {
  * 不在调用点手写 `config.remoteExec !== undefined`(门 D R4)。
  */
 export declare function buildNoticeLaneFacts(lane: ExecutionLane): Pick<MemoryFaceFacts, "handsWired" | "filePlaneRemote">;
+/**
+ * 披露的三种结局。`"roster"` = 部署事实答不完,剩下的问题(「名册上还剩不剩已知落盘路」)只有引擎在 prepare
+ * 之后知道 —— 由 {@link withNoPersistentMemoryNotice} 在装配时刻读 provider 拿到的名册作答,不在 resolveSpec 期猜。
+ */
+export type NoPersistentMemoryNotice = "disclose" | "silent" | "roster";
 /**
  * 该不该把 `NO_PERSISTENT_MEMORY_NOTICE` 组进本次任务的 system prompt。
  *
  * 优先序(每一条都有独立理由,不是同一条判据的三种写法):
- *  ① engine 在场 ⇒ **否**(引擎的座位,见文件头注);
- *  ② 部署显式声明(或 host 腿装配层自动声明)⇒ 声明说了算(`true` 撤回 / `false` 强制)—— operator 的部署
+ *  ① engine 在场 ⇒ `silent`(引擎的座位,见文件头注);
+ *  ② 部署显式声明(或 host 腿装配层自动声明)⇒ 声明说了算(`true` ⇒ `silent` / `false` ⇒ `disclose`)—— operator 的部署
  *     事实压过我们的推断,与 core 对 `memoryPersistenceCapable` 的处置同向;
- *  ③ 否则推断:有已知落盘路(手带挂上、场景不摘手、不是只读、文件平面在本机、且没被卸载决定卸光)⇒ 否;没有 ⇒ 是。
+ *  ③ 否则推断:手带没挂 / 场景摘手 / 只读 / 文件平面不在本机 ⇒ `disclose`;都不是 ⇒ `roster`(名册上还剩不剩已知落盘路,
+ *     读引擎选择器之后的名册 —— 本模块不读请求的任何工具名表,core 7.49.0 #1623 起那是引擎一只运算的输入)。
  * 🔴 S-602 只改臂③ 里「车道」那一段(`handsWired` / `filePlaneRemote`),①② 的优先序一字不动 —— 「in-process ⇒
  * 披露」只在这两臂**之后**成立(挂了记忆面、或声明了 capable 的 in-process 部署照旧不披露)。
  */
-export declare function shouldDiscloseNoPersistentMemory(facts: MemoryFaceFacts): boolean;
+export declare function noPersistentMemoryNotice(facts: MemoryFaceFacts): NoPersistentMemoryNotice;
+/**
+ * 名册臂:引擎选择器之后的名册上还剩不剩已知落盘路(`KNOWN_PERSISTENCE_TOOL_NAMES` 任一名在册)。⚠️ 负控:摘掉**一个**
+ * `Write` 不算断链(Bash / Edit 还在)—— 必须**全部**已知落盘路都不在名册上。名册为空(`excludeAllTools`)⇒ 一条都不剩。
+ */
+export declare function rosterLeavesPersistencePath(tools: readonly {
+    readonly name: string;
+}[]): boolean;
 /**
  * 把披露段组进一个 prompt provider,**按 provider 自己的钩子形分腿**(换形会改段身份与 append 座位):
  *  · typed(`stableBlocks`)⇒ {@link mountNotice}(普通形追加 behavior 声明;已组装 identity 形接在其文本后)。
@@ -129,5 +134,5 @@ export declare function shouldDiscloseNoPersistentMemory(facts: MemoryFaceFacts)
  * 走 typed 声明腿就没有这条耦合:role 层仍由 core 按 `userSystemPrompt ?? DEFAULT_SYSTEM_PROMPT` 自己铸,
  * 我方只贡献一条 behavior 段,`providerDropsAppend` 的判决包装前后逐格相同。
  */
-export declare function withNoPersistentMemoryNotice(provider: PromptProvider | undefined): PromptProvider;
+export declare function withNoPersistentMemoryNotice(provider: PromptProvider | undefined, when: Exclude<NoPersistentMemoryNotice, "silent">): PromptProvider;
 //# sourceMappingURL=memory-notice.d.ts.map

package/dist/capabilities/memory-notice.js

@@ -26,24 +26,21 @@ export function buildNoticeLaneFacts(lane) {
     const caps = executionLaneCaps(lane);
     return { handsWired: caps.coreRemoteExecutionEnv === "supported", filePlaneRemote: caps.hostFilePlane !== "supported" };
 }
-function isUnmounted(facts, name) {
-    return facts.excludeAllTools || (facts.excludeTools?.includes(name) ?? false);
-}
-function anyPersistenceToolSurvives(facts) {
-    return KNOWN_PERSISTENCE_TOOL_NAMES.some((name) => !isUnmounted(facts, name));
-}
-export function shouldDiscloseNoPersistentMemory(facts) {
+export function noPersistentMemoryNotice(facts) {
     if (facts.memoryFaceMounted)
-        return false;
+        return "silent";
     if (facts.declaredCapable !== undefined)
-        return !facts.declaredCapable;
+        return facts.declaredCapable ? "silent" : "disclose";
     if (facts.hands === "none" || facts.handsReadOnly)
-        return true;
+        return "disclose";
     if (!facts.handsWired)
-        return true;
+        return "disclose";
     if (facts.filePlaneRemote)
-        return true;
-    return !anyPersistenceToolSurvives(facts);
+        return "disclose";
+    return "roster";
+}
+export function rosterLeavesPersistencePath(tools) {
+    return tools.some((t) => KNOWN_PERSISTENCE_TOOL_NAMES.includes(t.name));
 }
 const NOTICE_BLOCK = { id: NO_PERSISTENT_MEMORY_SECTION_ID, slot: "behavior", text: NO_PERSISTENT_MEMORY_NOTICE };
 function mountNotice(decls) {
@@ -52,15 +49,16 @@ function mountNotice(decls) {
         return [...decls, NOTICE_BLOCK];
     return decls.map((d) => (d === assembledIdentity ? { id: d.id, slot: d.slot, text: `${d.text}\n\n${NO_PERSISTENT_MEMORY_NOTICE}` } : d));
 }
-export function withNoPersistentMemoryNotice(provider) {
+export function withNoPersistentMemoryNotice(provider, when) {
+    const due = (ctx) => when === "disclose" || !rosterLeavesPersistencePath(ctx.tools);
     if (provider?.stableBlocks) {
         const blocks = provider.stableBlocks.bind(provider);
-        return { ...provider, stableBlocks: (ctx) => mountNotice(blocks(ctx)) };
+        return { ...provider, stableBlocks: (ctx) => (due(ctx) ? mountNotice(blocks(ctx)) : blocks(ctx)) };
     }
     if (provider?.stableSystem) {
         const stable = provider.stableSystem.bind(provider);
-        return { ...provider, stableSystem: (ctx) => `${stable(ctx)}\n\n${NO_PERSISTENT_MEMORY_NOTICE}` };
+        return { ...provider, stableSystem: (ctx) => (due(ctx) ? `${stable(ctx)}\n\n${NO_PERSISTENT_MEMORY_NOTICE}` : stable(ctx)) };
     }
-    return { stableBlocks: () => [NOTICE_BLOCK] };
+    return { stableBlocks: (ctx) => (due(ctx) ? [NOTICE_BLOCK] : []) };
 }
 //# sourceMappingURL=memory-notice.js.map

package/dist/capabilities/scenarios.d.ts

@@ -1,10 +1,9 @@
 import { type WebFetchConfig, type BackgroundAgentStore, type CheckpointStore, type PromptProvider, type Runner, type SkillSpec, type TaskListStore, type ToolSpec, type WebSearchConfig } from "@sema-agent/core";
-import type { Metrics } from "../observability/metrics.js";
 import type { Logger } from "../observability/logger.js";
 import { type SubagentExtraToolSet } from "./builtin-tools.js";
 import { type RepoReadClient } from "./repo-tools.js";
 import { type LoadedSkill } from "./skills.js";
-import { type ScenarioHands } from "./hands-lane.js";
+import type { ScenarioHands } from "./hands-lane.js";
 /**
  * Scenario routing — a deployment serves many scenarios from one image. Each request's `scenario`
  * selects a pre-wired capability bundle: tools (incl. subagent roster) + a whole-harness prompt +
@@ -53,15 +52,8 @@ export interface ScenarioContext {
 export type Scenario = (req: ScenarioRequest, principal?: string, ctx?: ScenarioContext) => ScenarioBundle;
 export interface ScenarioDeps {
     runner: Runner;
-    /** In-memory runner for ephemeral sub-tasks (council lenses/arbiter) — keeps them out of TiDB. */
+    /** The runner a delegated (Agent-tool) child runs on — same deps as `runner`, hands included (CC parity). */
     subRunner: Runner;
-    /**
-     * [ref]:`subRunner` 的无手孪生 —— 同 deps,唯独不挂 `executionEnvFactory`。hands=none 的场景把它交给
-     * 自己造的子任务工具(council 的 lens/arbiter、discuss 的成员/synthesizer):那些子任务只该读仓库/讨论,
-     * 拿全量可写手是 [ref] 病灶里最意外的一支(零工具人格照拿 Bash)。取用一律走 {@link pickHandsRunner},
-     * 不在场景体内手挑 —— 判别位是唯一开关。
-     */
-    handslessSubRunner: Runner;
     model: string;
     skills: LoadedSkill[];
     repoClient?: RepoReadClient;
@@ -77,12 +69,11 @@ export interface ScenarioDeps {
      *  模型摘要而非整页灌上下文([ref] L1 的 ~660× 放大就是这缝);缺席 ⇒ `webFetch` 键不铸(修前
      *  字节形,core 落「summarization unavailable」诚实兜底)。 */
     webFetchSummarize?: NonNullable<NonNullable<WebFetchConfig["summarize"]>>;
-    metrics?: Metrics;
     logger?: Logger;
     /**
      * When true, the `default` scenario carries the Sema product identity (see {@link semaIdentityProvider}).
      * Set by the local/TOC deployment (CONFIG_PROVIDER=local / run-local) so the local engine answers "who
-     * are you" as Sema instead of the model's hallucinated identity. Business scenarios (discuss/code-review)
+     * are you" as Sema instead of the model's hallucinated identity. Business scenarios (code-review)
      * keep their own prompts; cloud (CONFIG_PROVIDER≠local) leaves the default scenario neutral unless turned
      * on, so integrators that inject their own persona are unaffected.
      */
@@ -205,9 +196,13 @@ export interface ScenarioDetail {
     /** 机读原因键;仅 `available:false` 时在场(缺席=没有理由)。消费方按键分支,禁匹配英文文案。 */
     unavailableReason?: ScenarioUnavailableReason;
 }
-/** 内建五场景详情。default/code/discuss 工厂对良性请求无副作用可真调(拿真实工具名单);code-review/scan 是
+/** 内建四场景详情。default/code 工厂对良性请求无副作用可真调(拿真实工具名单);code-review/scan 是
  *  fail-loud 语义(缺 GIT_API 配置/principal 即 throw)→ 探针失败落静态表兜底(表↔工厂一致性由测试锁:
  *  测试喂 fake deps 真调工厂对账工具名)。enabled 对内建恒 true(约定②)。 */
+/** 内建场景名的闭集(`GET /v1/capabilities.scenarios` 与场景详情口的内建成员)。{@link builtinScenarioDetails} 的返回型按它键控 ⇒ 加 / 删一个内建场景而
+ *  这里没跟 = 编译红;wire 变更清单的自铸登记表(`trace/self-minted-wire.ts` 的 `builtinScenario`)同按它 `satisfies`。 */
+export declare const BUILTIN_SCENARIO_NAMES: readonly ["code", "default", "code-review", "scan"];
+export type BuiltinScenarioName = (typeof BUILTIN_SCENARIO_NAMES)[number];
 export declare function builtinScenarioDetails(scenarios: Record<string, Scenario>, deps: Pick<ScenarioDeps, "brandIdentity" | "repoClient">): Record<string, ScenarioDetail>;
 /** center 条目详情(有效性判定与 centerScenarios 完全同款:无效条目既不进 overlay 也不进详情——
  *  保证约定①「详情显示的来源=运行实际用的定义」永不错位)。 */
@@ -236,7 +231,7 @@ export type ScenarioAvailability = {
  *
  * 判据键 = **toolset**:内建详情与 center 条目都带这个字段,故两条产线天然共用同一份判据。
  * `requiresRepo` 的 toolset 需要部署配好 git 后端(`GIT_API_BASEURL` ⇒ `deps.repoClient`)。
- * 词表外的 toolset(内建的 `full-body`/`discuss`)不依赖后端 ⇒ 恒可用。
+ * 词表外的 toolset(内建的 `full-body`)不依赖后端 ⇒ 恒可用。
  */
 export declare function scenarioAvailability(deps: Pick<ScenarioDeps, "repoClient">, toolset: string): ScenarioAvailability;
 /** 拒绝文案的唯一属主:闭集穷举 switch(新增原因词不在这里表态即编译红)。 */

package/dist/capabilities/scenarios.js

@@ -2,12 +2,9 @@ import { CODE_AGENT_PROMPT, CODE_SYSTEM_PROMPT, DEFAULT_SYSTEM_PROMPT, WEB_FETCH
 import { HttpError, createCodedHttpError } from "../security.js";
 import { createSubagentExtraTools, extraToolsErrorFields, nowTool } from "./builtin-tools.js";
 import { parseRepo, repoToolsFor } from "./repo-tools.js";
-import { createCouncilTool, clampRounds } from "./code-review-council.js";
 import { stablePrompt } from "./prompt.js";
-import { createDiscussionTools, discussionCoordinatorPrompt, getTeam, teamNames } from "./team.js";
 import { createWebSearchBackend, judgeRequestWebSearch } from "../plugins/web-search.js";
 import { skillsForScenario } from "./skills.js";
-import { pickHandsRunner } from "./hands-lane.js";
 export { SEMA_IDENTITY } from "./prompts/identity.js";
 import { SEMA_IDENTITY } from "./prompts/identity.js";
 export function semaIdentityProvider() {
@@ -28,9 +25,6 @@ export function codePromptProvider(brand) {
         ],
     };
 }
-function subRunnerFor(deps, hands) {
-    return pickHandsRunner(hands, { full: deps.subRunner, handsless: deps.handslessSubRunner });
-}
 function requestWebSearchBackend(verdict, deployment, logger) {
     switch (verdict.kind) {
         case "absent":
@@ -61,7 +55,7 @@ export function buildScenarios(deps) {
                         ? { taskListStore: deps.taskListStoreFor(ctx.sessionId) }
                         : {}),
                     subagent: {
-                        runner: subRunnerFor(deps, "full"),
+                        runner: deps.subRunner,
                         background: {
                             registry: defaultTaskRegistry,
                             owner: "unattributed",
@@ -101,22 +95,6 @@ export function buildScenarios(deps) {
                 skills: skillsForScenario(deps.skills, "scan"),
             };
         },
-        discuss: (req) => {
-            const name = typeof req.team === "string" ? req.team : "default";
-            const template = getTeam(name);
-            if (!template) {
-                throw new HttpError(404, `unknown discussion roster "${name}" (available: ${teamNames().join(", ")})`);
-            }
-            const objective = typeof req.objective === "string" ? req.objective : "Discuss the task.";
-            const businessContext = typeof req.businessContext === "string" ? req.businessContext : undefined;
-            const hands = "none";
-            return {
-                tools: createDiscussionTools(subRunnerFor(deps, hands), template, { objective, businessContext, ...(deps.logger ? { logger: deps.logger } : {}) }),
-                hands,
-                skills: skillsForScenario(deps.skills, "discuss"),
-                promptProvider: discussionCoordinatorPrompt,
-            };
-        },
     };
 }
 export function selectScenario(scenarios, name) {
@@ -131,6 +109,7 @@ function availabilityFields(deps, toolset) {
     const verdict = scenarioAvailability(deps, toolset);
     return verdict.available ? { available: true } : { available: false, unavailableReason: verdict.reason };
 }
+export const BUILTIN_SCENARIO_NAMES = ["code", "default", "code-review", "scan"];
 export function builtinScenarioDetails(scenarios, deps) {
     const probe = (name, req, principal, fallback) => {
         try {
@@ -145,15 +124,15 @@ export function builtinScenarioDetails(scenarios, deps) {
         name, source: "builtin", builtin: true, summary, toolset, tools, promptSummary, enabled: true,
         ...availabilityFields(deps, toolset),
     });
-    return {
+    const details = {
         code: mk("code", "编码主场景([891] 出厂缺省;CC 编码 persona 蒸馏版,default 全量工具面;终验旋钮独立)", "full-body", probe("code", {}, undefined, ["Now"]), deps.brandIdentity
             ? "Sema 产品身份 + core 编码完全体提示词(CODE_AGENT persona+自治自检;CC 血统对表)"
             : "core 编码完全体提示词(CODE_AGENT persona+自治自检;CC 血统对表)"),
         default: mk("default", "通用/助理场景(域中性 persona,CC agent loop 全量工具面;[891] 起非出厂缺省,显式可选)", "full-body", probe("default", {}, undefined, ["Now"]), deps.brandIdentity ? "Sema 产品身份 + core 默认宪法(结构层由引擎合成)" : "core 默认宪法(中性,无场景附加 persona)"),
-        "code-review": mk("code-review", "代码评审(clone-free 只读仓库工具;council=true 升多镜头评审团)", "repo-readonly", probe("code-review", { repo: "probe/probe" }, undefined, REPO_TOOLS), "评审员/评审团协调提示词(镜头分工+产出契约)"),
+        "code-review": mk("code-review", "代码评审(clone-free 只读仓库工具)", "repo-readonly", probe("code-review", { repo: "probe/probe" }, undefined, REPO_TOOLS), "评审员提示词(产出契约)"),
         scan: mk("scan", "中性只读仓库扫描(输出契约由 objective+skills 决定)", "repo-readonly", probe("scan", { repo: "probe/probe" }, undefined, REPO_TOOLS), "无场景附加提示词(objective+center skills 拥有输出契约)"),
-        discuss: mk("discuss", "多智能体讨论圆桌(模板成员+synthesizer,模板可由 registry 配置)", "discuss", probe("discuss", {}, undefined, ["run_discussion"]), "讨论协调者提示词(圆桌纪律+合成流程)"),
     };
+    return details;
 }
 export function centerScenarioDetails(specs, builtinNames, deps) {
     const out = {};
@@ -249,28 +228,7 @@ function codeReview(deps, req) {
     const coords = parseRepo(req.repo);
     const repoTools = repoToolsFor(repoClient, coords);
     const skills = skillsForScenario(deps.skills, "code-review");
-    const objective = typeof req.objective === "string" ? req.objective : "Review this repository.";
     const hands = "none";
-    if (req.lenses !== undefined && typeof req.lenses !== "number") {
-        throw new HttpError(400, "lenses must be a number (council lens COUNT, 1-6) — a named lens subset is not a request-level knob", { code: "request.field_invalid" });
-    }
-    if (req.council === true) {
-        const rounds = clampRounds(req.rounds);
-        return {
-            tools: [
-                createCouncilTool(subRunnerFor(deps, hands), repoTools, objective, {
-                    metrics: deps.metrics,
-                    logger: deps.logger,
-                    debate: req.debate === true,
-                    ...(typeof req.lenses === "number" ? { lensCount: req.lenses } : {}),
-                    ...(rounds !== undefined ? { rounds } : {}),
-                }),
-            ],
-            hands,
-            skills,
-            promptProvider: coordinatorPrompt,
-        };
-    }
     return { tools: [...repoTools, nowTool()], hands, skills, promptProvider: directReviewerPrompt };
 }
 const reviewBody = "Produce ONE prioritized review: a short summary, then findings grouped by severity " +
@@ -278,9 +236,6 @@ const reviewBody = "Produce ONE prioritized review: a short summary, then findin
 const directReviewerPrompt = stablePrompt("You are a senior code reviewer. Call repo_tree to map the repository, then repo_read_file to read " +
     "the files in scope, then review them yourself. " +
     reviewBody);
-const coordinatorPrompt = stablePrompt("You coordinate a code-review council. Call `run_council` exactly once (no arguments). When it " +
-    "returns the arbitrated review, output that review as your final answer VERBATIM — do not " +
-    "summarize, shorten, or rewrite it.");
 export function mergeUserSkills(scenarioSkills, userSkills, logger) {
     if (!userSkills || userSkills.length === 0)
         return scenarioSkills;

package/dist/capability-facts.d.ts

@@ -24,6 +24,7 @@ import type { OwnerAwareSessionStore } from "./security.js";
 import type { ServiceFileHistoryStore } from "./plugins/store-backend.js";
 import { resolveStreamApprovalGate } from "./tool-approval.js";
 import { type WorkspaceSyncCapability } from "./workspace-space.js";
+import type { WorkspaceCacheCapability } from "./workspace-cache.js";
 /** why 闭集:词 → 给运维看的一句义(诊断 / 测试读它;wire 上的拒句由各门自写)。 */
 export declare const CAPABILITY_FACT_WHY: {
     readonly run_store_absent: "no durable run store is wired (DB_BACKEND=mysql|pg|local)";
@@ -83,6 +84,7 @@ export declare const CAPABILITY_FACT_WHY: {
     readonly not_host_lane: "the execution lane is not the single-user host lane (REMOTE_EXEC=host)";
     readonly not_k8s_lane: "the execution lane is not the k8s pod sandbox (REMOTE_EXEC=k8s)";
     readonly workspace_snapshot_store_absent: "no workspace snapshot store is configured (MINIO_ENDPOINT / MINIO_ACCESS_KEY / MINIO_SECRET_KEY)";
+    readonly workspace_cache_off: "the build-cache volume per workspace space is off (WORKSPACE_CACHE=off, the default)";
 };
 export type CapabilityFactWhy = keyof typeof CAPABILITY_FACT_WHY;
 /** 不可用臂。 */
@@ -155,11 +157,11 @@ export declare function sessionPolicy(d: Pick<Deps, "sessionPolicyStore" | "sess
     policyStore: Store<"sessionPolicyStore">;
     sessionStorage: OwnedSessionStore;
 }>;
-type SyncSessionStore = WithMethods<OwnerAwareSessionStore, "ownerOf" | "exportEntries" | "exportEntriesStream" | "beginImportStaging" | "sessionFaceOf" | "sessionSummaryOf" | "patchSessionMeta">;
-type SessionSyncWhy = "store_backend_absent" | "session_owner_face_absent" | "file_history_store_absent" | "session_export_absent" | "session_import_staging_absent" | "session_row_faces_absent" | "policy_purge_absent";
-/** 会话对等同步的**对话半族**(manifest / entries / plan / import 两相):后端 ∧ 属主面 ∧ 文件历史店 ∧ 导出两面 ∧
- *  staged 导入面 ∧ 会话行三口(manifest 带 `title` / `pinned`、导入经唯一写口按导入落定的那一位住客重放它们 —— 会话面读住客)∧
- *  policy 店能清(overwrite-dst 的 commit 要擦目的端旧 policy 行)。
+type SyncSessionStore = WithMethods<OwnerAwareSessionStore, "exportEntries" | "exportEntriesStream" | "beginImportStaging" | "sessionFaceOf" | "sessionSummaryOf" | "patchSessionMeta">;
+type SessionSyncWhy = "store_backend_absent" | "file_history_store_absent" | "session_export_absent" | "session_import_staging_absent" | "session_row_faces_absent" | "policy_purge_absent";
+/** 会话对等同步的**对话半族**(manifest / entries / plan / import 两相):后端 ∧ 文件历史店 ∧ 导出两面 ∧ staged 导入面 ∧
+ *  会话行三口(门读会话面 —— 属主 + 化身一次读,属主判门、化身给 identical 短路腿;manifest 带 `title` / `pinned`;导入经唯一写口按导入落定的
+ *  那一位住客重放它们)∧ policy 店能清(overwrite-dst 的 commit 要擦目的端旧 policy 行)。
  *  文件历史的 blob 搬运是另一只事实。 */
 export declare function sessionSync(d: Pick<Deps, "backend" | "sessionStorage" | "fileHistoryStore" | "sessionPolicyStore">): Fact<SessionSyncWhy, {
     backend: Store<"backend">;
@@ -303,18 +305,27 @@ export declare function workflowsJournal(d: Pick<Deps, "workflowRunStore" | "wor
     journal: Store<"workflowJournalStore">;
 }>;
 /**
- * k8s 车道工作区跨轮保留的有效策略 —— k8s 车道 ∧ 快照存储在场 ⇒ `{ persist, keep }`(未表态的旋钮取缺省,缺省值属主
- * `workspace-space.ts`;`persist` 缺省 `off`,opt-in `space`)。**唯一读法**:能力位 `workspaceSync` 投影它的见证,k8s 适配器工厂(`boot/execution-env.ts`)把同一份
+ * k8s 车道工作区跨轮保留的有效策略 —— k8s 车道 ∧ 快照存储在场 ⇒ `{ persist, keep, timeoutMs }`(未表态的旋钮取缺省,缺省值属主
+ * `workspace-space.ts`;`persist` 缺省 `space`,`off` = 每轮新建)。**唯一读法**:能力位 `workspaceSync` 投影它的见证,k8s 适配器工厂(`boot/execution-env.ts`)把同一份
  * 见证交给适配器(适配器自己不再解析策略)。`persist: "off"` 仍是 available(存储在、没开 —— 缺省或运维显式 off)—— 与缺席不同义。
  *
- * **为何只读配置仍恒真**:`space` 的空间按会话住客分区,住客只有一只读口 —— 会话店的 `sessionFaceOf`。会话店没有它(内存会话店)的
- * 组合在起服时就被拒(`boot/execution-env.ts` 的 `assertWorkspaceSpaceReadable`,装配第 5 段,读的正是本事实的见证)⇒ 凡是起得来、
- * 报 `space` 的部署都读得出住客,本事实不需要运行期依赖(再加一位 = 同一前提两处判)。剩下的「这条 run 读不到住客」是逐 run 的读失败
- * (适配器的 `unavailable` 臂,响亮一行),不是部署形。
+ * **为何只读配置仍恒真**:`space` 的空间按会话住客分区、按 run 店的一行提交 —— 住客只有一只按 id 读(会话店的 `incarnationOf`,
+ * 会话行上的那一格),行住在存储后端里。缺一的组合在起服时就被拒(`boot/execution-env.ts` 的 `assertWorkspaceSpaceReadable`,装配第 5 段,
+ * 读的正是本事实的见证)⇒ 凡是起得来、报 `space` 的部署都读得出住客、写得下行,本事实不需要运行期依赖(再加一位 = 同一前提两处判)。
+ * 剩下的「这条 run 读不到住客」是逐 run 的读失败(适配器的 `unavailable` 臂,响亮一行),不是部署形。
  */
 export declare function workspaceSpace(c: Pick<ServiceConfig, "remoteExec">): Fact<"not_k8s_lane" | "workspace_snapshot_store_absent", {
     policy: WorkspaceSyncCapability;
 }>;
+/**
+ * k8s 车道按工作区空间的构建缓存卷的有效策略 —— k8s 车道 ∧ `WORKSPACE_CACHE=volume` ⇒ `{ mount, size }`(缺省值属主 `workspace-cache.ts`)。
+ * **唯一读法**:能力位 `workspaceSync.cache` 投影它的见证,k8s 适配器工厂(`boot/execution-env.ts`)把同一份见证交给适配器。与快照存储无关
+ * (卷属于空间,不属于快照)。为何只读配置仍恒真:卷按会话住客键控,住客读口缺席的组合起服即拒(`assertWorkspaceSpaceReadable`);剩下的
+ * 「这条 run 拿不到卷」是逐 run 的 F 类放行(`server.workspace-cache.unavailable` 计数 + 一行),不是部署形。
+ */
+export declare function workspaceCache(c: Pick<ServiceConfig, "remoteExec">): Fact<"not_k8s_lane" | "workspace_cache_off", {
+    cache: WorkspaceCacheCapability;
+}>;
 /** 自唤醒调度器挂在宿主 env 上:`SCHEDULER_ENABLED` ∧ 单用户 ∧ host 车道。装配(`boot/execution-env.ts`)与能力位同调。 */
 export declare function hostScheduler(c: Pick<ServiceConfig, "schedulerEnabled" | "requirePrincipal" | "remoteExec">): Fact<"scheduler_disabled" | "multi_tenant_deployment" | "not_host_lane">;
 export {};

package/dist/capability-facts.js

@@ -3,7 +3,7 @@ import { resolveStreamApprovalGate } from "./tool-approval.js";
 import { selfOrchestrationDenial } from "./task-workflow.js";
 import { centerEntitlementSourceWired } from "./runtime-caps-resolver.js";
 import { overwriteWipeIncapable } from "./session-sync.js";
-import { WORKSPACE_PERSIST_DEFAULT, WORKSPACE_SNAPSHOT_KEEP_DEFAULT } from "./workspace-space.js";
+import { WORKSPACE_PERSIST_DEFAULT, WORKSPACE_SNAPSHOT_KEEP_DEFAULT, workspaceSnapshotTimeoutOf } from "./workspace-space.js";
 export const CAPABILITY_FACT_WHY = {
     run_store_absent: "no durable run store is wired (DB_BACKEND=mysql|pg|local)",
     subagent_registry_absent: "the sub-agent steer registry is not wired",
@@ -62,6 +62,7 @@ export const CAPABILITY_FACT_WHY = {
     not_host_lane: "the execution lane is not the single-user host lane (REMOTE_EXEC=host)",
     not_k8s_lane: "the execution lane is not the k8s pod sandbox (REMOTE_EXEC=k8s)",
     workspace_snapshot_store_absent: "no workspace snapshot store is configured (MINIO_ENDPOINT / MINIO_ACCESS_KEY / MINIO_SECRET_KEY)",
+    workspace_cache_off: "the build-cache volume per workspace space is off (WORKSPACE_CACHE=off, the default)",
 };
 const no = (why) => ({ available: false, why });
 const yes = (w) => ({ available: true, ...w });
@@ -152,12 +153,10 @@ export function sessionPolicy(d) {
 export function sessionSync(d) {
     if (d.backend === undefined)
         return no("store_backend_absent");
-    const s = d.sessionStorage;
-    if (s?.ownerOf === undefined)
-        return no("session_owner_face_absent");
     if (d.fileHistoryStore === undefined)
         return no("file_history_store_absent");
-    if (s.exportEntries === undefined || s.exportEntriesStream === undefined)
+    const s = d.sessionStorage;
+    if (s?.exportEntries === undefined || s.exportEntriesStream === undefined)
         return no("session_export_absent");
     if (s.beginImportStaging === undefined)
         return no("session_import_staging_absent");
@@ -360,7 +359,15 @@ export function workspaceSpace(c) {
         return no("not_k8s_lane");
     if (!rx.s3Snapshot)
         return no("workspace_snapshot_store_absent");
-    return yes({ policy: { persist: rx.workspacePersist ?? WORKSPACE_PERSIST_DEFAULT, keep: rx.workspaceSnapshotKeep ?? WORKSPACE_SNAPSHOT_KEEP_DEFAULT } });
+    return yes({ policy: { persist: rx.workspacePersist ?? WORKSPACE_PERSIST_DEFAULT, keep: rx.workspaceSnapshotKeep ?? WORKSPACE_SNAPSHOT_KEEP_DEFAULT, timeoutMs: workspaceSnapshotTimeoutOf(rx) } });
+}
+export function workspaceCache(c) {
+    const rx = c.remoteExec;
+    if (rx?.provider !== "k8s")
+        return no("not_k8s_lane");
+    if (rx.workspaceCache === undefined)
+        return no("workspace_cache_off");
+    return yes({ cache: { mount: rx.workspaceCache.mount, size: rx.workspaceCache.size } });
 }
 export function hostScheduler(c) {
     if (c.schedulerEnabled !== true)