@sema-agent/server 7.43.0 → 7.44.0

package/dist/capabilities/center-prompts.js

@@ -1,48 +1,15 @@
-/**
- * center prompts 消费投影腿([1043]④/[1050]③ 分工:web 承存储+covering 解析+下发,server 承本模块;
- * [1057] 下发形定稿 / [1061] registry-core 0.10.16 schema / [1062]⑤「server 零新义务=逐字透传」)。
- *
- * 链路:center(sema-web)把 covering 走完的**基线终形**经 `GET /api/config/effective` 的 additive
- * `prompts` key 下发 → 本模块按任务 scenario 选包(`scenarioOverrides[s] ?? sections`,整包替换非增量,
- * [1057]①c)→ 声明数组**逐字**(含 opt-in `contentHash`,core 1.315 校验+manifest 透传)喂 core 既有
- * typed `stableBlocks` 钩子。守卫全在 core(id 规范/slot 闭集/core/ 命名空间拒绝/identity 三锚
- * pass-through/锁定槽不可写)——server 不做语义复检([1057]①f:identity 完整角色层由 center 编辑面把关)。
- *
- * 仅有的一层「形校验」不是语义复检,是**防炸底线**(详见其现居所 `src/prompts-domain-validate.ts`——
- * 判形半场已下沉到该中立叶子,本文件 re-export 保兼容;design/158 S6,lens2 §G):core 对坏形声明的
- * 守卫是 THROW(assemble 期),server 在采用前做结构判形,坏形=拒绝采用该候选的 prompts 面。
- *
- * 生效语义(两段史):1.222 时 core 1.315 的 epoch 是 bundled-only(声明不进 descriptor),热换=resume
- * 三失真,故临时 restart-to-apply;core 1.316([1068] 裁 a/[1070]d)把声明以 (id,slot,chars,contentHash?)
- * 纳入 artifactDigest——声明变=digest 变=**下任务边界自动重 pin**(既有 legacy_migration 机制接手),
- * 进行中会话 epoch pin 保稳。自此恢复**热采用**(main.ts boot+refresh 双点 adopt),与 center
- * 「发布=新任务生效」产品语义对齐([1051]②b)。字节级检测只认 opt-in contentHash(文本不进 digest,
- * 防会话可导出面字典预映)——center 链路恒逐 section 铸([1065]),本投影逐字透传即全强度。
- */
 import { verifyPromptArtifact } from "@sema-agent/core";
 import { CORE_ENGINE_VERSION } from "../prompts-domain-validate.js";
-import { scenarioConfigKeys } from "./scenario-alias.js";
 import { SHA256_HEX_RE } from "../digest-form.js";
 import { recordFailOpen } from "../observability/fail-open.js";
-/** 判形半场(validateCenterPrompts/validatePromptsDomain/CORE_ENGINE_VERSION 及两 interface)已下沉到
- *  中立叶子 `src/prompts-domain-validate.ts`(design/158 S6);消费者直引真源([2354] 兼容面全清,
- *  此处兼容 re-export 已删)。 */
-/** [985]b / [1285] — §9.4 by-digest 补拉组合店:local miss ⇒ fetchRaw(digest) 从 center 拉 envelope ⇒
- *  core verifyPromptArtifact 全管线 + **回验「拿到的=要的」digest 逐位**(center 答非所问=丢弃)⇒
- *  best-effort 回写 inner(下次直命中)。任何失败=undefined(诚实缺席,fail-loud 归 core 的
- *  prompt_snapshot_unavailable——绝不拼杂交)。 */
 export function withPromptArtifactBackfill(inner, fetchRaw, log) {
-    // codex F1(补拉批):per-canonical-digest 单飞——冷副本上 N 个 pinned resume 同时 miss 同一 artifact
-    // 只发一次远拉(finally 清账);裸/大写形入口即正则化(FilePromptArtifactStore 只认 canonical 键,
-    // 不正则化=非 canonical 请求缓存永 miss 重拉)。坏形 digest 直拒(不上网)。负缓存有意不设:每次
-    // miss 都是用户驱动的 resume 尝试,量有界;404 重复由单飞在并发窗内已并。
     const inFlight = new Map();
     return {
         put: (e) => inner.put(e),
         get: async (digest, opts) => {
             const hex = digest.replace(/^sha256:/i, "").toLowerCase();
             if (!SHA256_HEX_RE.test(hex))
-                return undefined; // malformed request — never a network trip
+                return undefined;
             const canonical = `sha256:${hex}`;
             const local = await inner.get(canonical, opts);
             if (local)
@@ -58,8 +25,6 @@ export function withPromptArtifactBackfill(inner, fetchRaw, log) {
                         log.warn("center_prompts_backfill_rejected", { digest: canonical, ...(v.ok ? { got: v.artifact.artifactDigest, code: "digest_mismatch" } : { code: v.code, reason: v.reason }) });
                         return undefined;
                     }
-                    // cache best-effort —— #157:F 类兜底(工件已验签且已返回;失败的代价只是下次再取一次网络),
-                    // 留痕是为了让"缓存其实一直没写成"不必靠回填流量异常来发现。
                     await inner.put(raw).catch(() => recordFailOpen("server.prompts.artifact-cache-write-failed", `digest=${canonical}`));
                     log.info("center_prompts_backfilled", { digest: canonical });
                     return raw;
@@ -77,18 +42,11 @@ export function withPromptArtifactBackfill(inner, fetchRaw, log) {
         },
     };
 }
-/** e/b 接线([1236]① seam/[985]e):catalog 轴的两态过渡推进 core 的 CenterPromptSource——
- *  present(且身份变)⇒ applySnapshot(core 重验+落盘+原子换 candidate;validate 已过 core verify,
- *  此处失败=磁盘/状态写问题,warn 不挡 declaration 轴);absent-after-present / prompts 键整体消失
- *  ⇒ applyDisabled(闸关=显式撤下语义的 catalog 轴半场,离线重启不复活)。幂等安全:同 envelope
- *  重放=同 digest 覆盖写。 */
 export async function applyCatalogToSource(source, next, prev, log, phase) {
-    // codex-2 F2:返回「过渡是否成功」——false 时 caller **不推进** centerPrompts(身份留在 prev),
-    // 下一拍 refresh 身份仍不等=同一过渡自动重试;吞错推进曾让失败的 apply/withdraw 永久静默。
     try {
         if (next?.catalog) {
             if (prev?.identity === next.identity)
-                return true; // unchanged face — no state churn
+                return true;
             const r = await source.applySnapshot(next.catalog);
             if (r.ok) {
                 log.info("center_prompts_catalog_applied", { phase, artifactDigest: r.artifactDigest });
@@ -98,8 +56,6 @@ export async function applyCatalogToSource(source, next, prev, log, phase) {
             return false;
         }
         if (prev?.catalog || source.current?.() !== undefined) {
-            // the axis was live (in-memory marker OR a persisted candidate surviving a restart whose disable was
-            // owed) and the face now has no catalog: fail-closed mirror of the cleared semantics — disable durably.
             await source.applyDisabled(`${phase}:catalog-absent`);
             log.info("center_prompts_catalog_disabled", { phase, note: "catalog axis withdrawn — core candidate cleared (does not revive offline)" });
         }
@@ -110,41 +66,20 @@ export async function applyCatalogToSource(source, next, prev, log, phase) {
         return false;
     }
 }
-/**
- * 选包+投影:该 scenario 的终形声明数组(`scenarioOverrides[s] ?? sections`)→ typed `stableBlocks`
- * 钩子(声明**逐字**透传,含 contentHash——core 1.315 校验后进 manifest)。空数组在 validate 已拒
- * (F4:空替换集非 v1 语义),所以这里恒有非空声明——恒返回 provider(center-wins 无死分支)。
- */
 export function centerPromptProvider(prompts, scenarioName) {
     const decls = scenarioDecls(prompts, scenarioName);
-    // 声明数组在候选采用时已判形+冻结(main.ts ref 整体替换,数组不原位变异)——闭包直接引用,core 侧
-    // 1.315 还有声明边界快照(getter 无法让「验过的」≠「发出的」)。
     return { stableBlocks: () => decls };
 }
-/** codex R3(appendSystemPrompt 案):该 scenario 的终形 center 声明里是否有「已组装 identity」——core 的
- *  M9 迁移卫在 provider.stableBlocks 的 identity 声明上探同三锚,命中即走 pass-through 臂(其保留集无
- *  `core/role.append`,任何 append rider/outputStyle 会被静默丢)。选包与 {@link centerPromptProvider}
- *  同式(`overrides[s] ?? sections`);锚谓词由调用方注入(task-settings `hasConstitutionAnchors` 单真源)。
- *  [1057]①f 的「server 不做语义复检」不动:这不是复检语义,是为 capabilities.appendSystemPrompt 的诚实面
- *  探 core 会走哪条臂。 */
 export function centerIdentityAssembled(prompts, scenarioName, isAssembled) {
     return scenarioDecls(prompts, scenarioName).some((d) => d.slot === "identity" && isAssembled(d.text));
 }
-/** 选包的**唯一**实现(两个消费面共用,免得「谁赢」这条优先序有两份副本)。
- *  #273 alias 窗:`scenarioOverrides` 的键写**旧场景名**时同样命中(`scenarioConfigKeys`,主名优先)——
- *  运维已经写好的 per-scenario 提示词包不因改名当版静默失效。
- *  #193 P2-13 同族守卫(顺手补,收拢时发现):`Record` 的裸索引对原型链键会取到 `Object.prototype` 上的
- *  成员,而场景名词法 `SCENARIO_NAME_RE` 恰好**允许** `constructor` 这种名字 ⇒ 旧写法会把一个函数当
- *  声明数组返回,下游 `.some(...)` 直接 TypeError。own-property 判定后这条路不存在。 */
 function scenarioDecls(prompts, scenarioName) {
     const overrides = prompts.scenarioOverrides;
     if (overrides) {
-        for (const key of scenarioConfigKeys(scenarioName)) {
-            if (Object.hasOwn(overrides, key)) {
-                const hit = overrides[key];
-                if (hit)
-                    return hit;
-            }
+        if (Object.hasOwn(overrides, scenarioName)) {
+            const hit = overrides[scenarioName];
+            if (hit)
+                return hit;
         }
     }
     return prompts.sections;

package/dist/capabilities/code-review-council.js

@@ -1,45 +1,30 @@
 import { Type } from "typebox";
 import { runTeamDiscussion } from "@sema-agent/core";
-import { REVIEW_LENSES, GROUNDING, LENS_SYSTEM_TPL, DEBATE_MEMBER_TPL, DEBATE_TOPIC_TPL, ARBITER_SYSTEM, ARBITER_FALLBACK_HEADER } from "./prompts/code-review.js"; // bundle-data layer
-const LENSES = REVIEW_LENSES; // roster copy lives in prompts/code-review.ts
-/**
- * Caller-tunable lens COUNT (OA request) — a structured cost/coverage dial, sibling of `@model` / `council` /
- * `debate`. The deployment owns WHICH lenses (the `LENSES` order = the priority: security/correctness first =
- * the bug-finders); the caller only picks HOW MANY. Clamp to [1, LENSES.length]; absent / non-numeric = ALL
- * (the current default → zero regression). A named subset is deliberately NOT supported (it would force a
- * published, maintained lens vocabulary contract; the count is the verifiable knob a "light/standard" UI needs).
- */
+import { REVIEW_LENSES, GROUNDING, LENS_SYSTEM_TPL, DEBATE_MEMBER_TPL, DEBATE_TOPIC_TPL, ARBITER_SYSTEM, ARBITER_FALLBACK_HEADER } from "./prompts/code-review.js";
+const LENSES = REVIEW_LENSES;
 export function pickLenses(count) {
     if (count == null || !Number.isFinite(count))
         return LENSES;
     const n = Math.min(LENSES.length, Math.max(1, Math.floor(count)));
     return LENSES.slice(0, n);
 }
-/** Caller-settable debate rounds: a FINITE integer clamped to [1,3]; non-number / NaN / ±Infinity = undefined
- *  (→ the council's default of 1). Mirrors `pickLenses`'s `Number.isFinite` guard — the previous inline clamp let
- *  `NaN` through (`typeof NaN === "number"`, `Math.min(3, NaN) === NaN`), corrupting the cost metric (council). */
 export function clampRounds(rounds) {
     if (typeof rounds !== "number" || !Number.isFinite(rounds))
         return undefined;
     return Math.min(3, Math.max(1, Math.floor(rounds)));
 }
-// Guardrail COPY (GROUNDING/templates/arbiter) lives in prompts/code-review.ts — this file keeps
-// only the fill logic. `fillPrompt` is a plain `{key}` substitution (no escaping: values are our own lens
-// names/briefs and the objective/findings the model already sees verbatim elsewhere).
 function fillPrompt(tpl, vars) {
     return tpl.replace(/\{(\w+)\}/g, (m, k) => (k in vars ? vars[k] : m));
 }
 function lensSystem(lens) {
     return fillPrompt(LENS_SYSTEM_TPL, { name: lens.name, brief: lens.brief, grounding: GROUNDING });
 }
-// L2 — peer debate persona (guardrails 5,6): cross-examine, adjust confidence, verify disputes with tools.
 function debateMemberSystem(lens) {
     return fillPrompt(DEBATE_MEMBER_TPL, { name: lens.name, brief: lens.brief });
 }
 function debateTopic(objective, findings) {
     return fillPrompt(DEBATE_TOPIC_TPL, { objective, grounding: GROUNDING, findings });
 }
-/** Build the `run_council` tool. The lead calls it once; it returns the final arbitrated review. */
 export function createCouncilTool(subRunner, repoTools, objective, opts = {}) {
     return {
         name: "run_council",
@@ -48,23 +33,17 @@ export function createCouncilTool(subRunner, repoTools, objective, opts = {}) {
         effect: "read",
         parameters: Type.Object({}),
         execute: async (_args, ctx) => {
-            // Caller-chosen lens subset (OA cost/coverage dial); default = all lenses.
             const active = pickLenses(opts.lensCount);
-            // Forward the parent task's AbortSignal (core ≥1.18) so the lenses/arbiter stop the instant the
-            // parent is cancelled, instead of each burning to its own timeoutSec (design/16 feature request).
-            const lenses = await runLensReviews(subRunner, repoTools, objective, ctx.signal, active); // L1
+            const lenses = await runLensReviews(subRunner, repoTools, objective, ctx.signal, active);
             const findings = lenses.map((l) => `### ${l.lens} reviewer\n${l.text}`).join("\n\n");
-            const converge = await runConvergence(subRunner, repoTools, objective, findings, opts, ctx.signal, active); // L2?+L3
-            // Cost is otherwise invisible — the sub-tasks run on a separate runner, so the parent run's
-            // stats only count the lead. Surface the real (~Nx) cost three ways:
+            const converge = await runConvergence(subRunner, repoTools, objective, findings, opts, ctx.signal, active);
             const totalTokens = lenses.reduce((s, l) => s + l.tokens, 0) + converge.tokens;
             const totalTurns = lenses.reduce((s, l) => s + l.turns, 0) + converge.turns;
             const tasks = active.length + (opts.debate ? active.length * (opts.rounds ?? 1) + 1 : 1);
-            // ① into the PARENT run's TaskResult.stats.nested (core 1.11 reportUsage):
             ctx.reportUsage?.({ tokens: totalTokens, turns: totalTurns, tasks });
             const mode = opts.debate ? "L1+L2+L3" : "L1+L3";
             opts.metrics?.inc("council_runs_total", { mode });
-            opts.metrics?.inc("task_tokens_total", {}, totalTokens); // global counter, no labels — keep it honest
+            opts.metrics?.inc("task_tokens_total", {}, totalTokens);
             opts.metrics?.observe("council_tokens", totalTokens);
             opts.logger?.info("council_done", { mode, lenses: lenses.length, totalTokens, totalTurns });
             return {
@@ -74,15 +53,10 @@ export function createCouncilTool(subRunner, repoTools, objective, opts = {}) {
         },
     };
 }
-/** L1 — one isolated, repo-tooled subagent per lens, run in parallel. A single lens that throws
- *  (gateway 5xx / timeout) must NOT collapse the whole council, so failures degrade to a noted
- *  empty lens and arbitration proceeds on the survivors. */
 async function runLensReviews(subRunner, repoTools, objective, signal, lenses) {
     const settled = await Promise.allSettled(lenses.map(async (lens) => {
         const r = await subRunner.runTask({
             objective: `${objective}\n\nReview ONLY through the ${lens.name} lens.`,
-            // Cost tiering (1.24): lenses run on the `subagent` role — cheap when MODEL_CHEAP_ID is set,
-            // else the main model. Scanning for leads doesn't need the strong model; the arbiter does.
             modelRole: "subagent",
             tools: repoTools,
             systemPrompt: lensSystem(lens),
@@ -101,7 +75,6 @@ async function runLensReviews(subRunner, repoTools, objective, signal, lenses) {
             turns: 0,
         });
 }
-/** L2 (peer debate, tool-grounded) + L3 synthesis, or — when `debate` is off — L3 arbiter alone. */
 async function runConvergence(subRunner, repoTools, objective, findings, opts, signal, lenses) {
     if (opts.debate) {
         const team = await (opts.teamFn ?? runTeamDiscussion)({
@@ -110,14 +83,12 @@ async function runConvergence(subRunner, repoTools, objective, findings, opts, s
             members: lenses.map((l) => ({ role: l.name, systemPrompt: debateMemberSystem(l) })),
             topic: debateTopic(objective, findings),
             rounds: opts.rounds ?? 1,
-            tools: repoTools, // members may verify a disputed claim against the real code (Tool-MAD)
+            tools: repoTools,
             maxTranscriptTokens: 8000,
             synthesizer: { role: "arbiter", systemPrompt: ARBITER_SYSTEM },
             limits: { maxWalltimeMs: 400_000 },
-            signal, // 1.28: a parent abort now cascades into the debate members
+            signal,
         });
-        // 1.32: synthesizer 两次都失败时 `conclusion` 是 `[unavailable…]` 垃圾串，与真结论无法区分。别当结论
-        // 返回——退回未经仲裁的各 lens 原始发现（findings 在手），用户至少看到真实发现，而不是把垃圾当评审。
         if (!team.conclusionValid) {
             opts.logger?.warn("council_arbiter_failed", { failures: team.failures });
             return {
@@ -128,18 +99,14 @@ async function runConvergence(subRunner, repoTools, objective, findings, opts, s
         }
         return { review: team.conclusion, tokens: team.stats.tokens, turns: team.stats.turns };
     }
-    // L3 only — a single neutral arbiter (ground / dedup / bucket / rank). No new findings.
     const arb = await subRunner.runTask({
         objective: `Arbitrate these specialist findings into ONE final review:\n\n${findings}`,
-        // The arbiter grounds/dedups/ranks — keep it on the strong `synthesize` role (= main model).
         modelRole: "synthesize",
         systemPrompt: ARBITER_SYSTEM,
         limits: { maxWalltimeMs: 240_000 },
         enableBlockedReport: false,
         signal,
     });
-    // Mirror the debate path's fallback: an empty/failed arbiter result must not surface as an empty review —
-    // hand back the raw lens findings so the caller still sees real findings, not nothing.
     const review = arb.result?.trim() || `${ARBITER_FALLBACK_HEADER}${findings}`;
     return { review, tokens: arb.stats.tokens, turns: arb.stats.turns };
 }

package/dist/capabilities/collab-workflows.js

@@ -1,34 +1,9 @@
-/**
- * collab → named-workflow projection — 翻译层**切片 1.5**(design/140 统一解:
- * 「模式=内置命名 workflow profile,一期零新引擎机制」;core 1.263.0 三件落地后的靶点切换)。
- *
- * 切片① 的 runTeamDiscussion 投影(collab-project.ts)已随本切片**整体替换**(同款纪律:别留双路径
- * 降级)。新形态:每个可投影的 CollabTemplate 翻译成一条**命名 workflow 注册条目**——
- *
- *   `Workflow({name: <collab id>})` ⇒ 执行体 = core 内置 `TEAM_DISCUSSION_SCRIPT`(pure script content,
- *   零新机制)+ `defaultArgs` = 本模板的 slots/rounds/finalizer 翻译(args 合并链第二级:调用时 args >
- *   本注册 defaults > 脚本内置兜底,core `mergeWorkflowArgs` 在 tool-resolve 时点快照)。center「只配模式
- *   各 slot 的模型」的拍板意图恰好=defaultArgs 这一级;调用者仍可用 args.topic/members 覆盖。
- *
- * 可投影子集(团队讨论 profile 能忠实执行的语义;其余整条跳过+结构化上报,绝不静默降级):
- *   topology ∈ {ring, pair}(round-based 顺序发言=脚本真实形态;star/layered 等 core 后续 profile)∧
- *   finalizer.type = "summarize"(→脚本 finalizer;judge/vote/fuse/verify 裁决族=后续 profile)∧
- *   sharedContext = {transcript, session} ∧ 全 slot 无 tools(工具绑定=执行面后续)。
- *
- * 语义注记(投影成功但记录):脚本对 members cap 6 / rounds cap 5(确定性截断)——超界模板照投+note;
- * CollabTemplate.budget=模板级预算无 per-name workflow 通道(WorkflowLimits 是部署级、per-child 强制轴
- * 已有)→ 记 note,引擎 budget 硬顶+部署 maxTask* 闸兜底(与切片① 结论一致)。
- *
- * 纯函数投影 + 模块级可变注册表(registerTeams 同款单例姿势,applyEffective boot+refresh 热更);
- * 消费点 = main.ts 的 composite WorkflowScriptStore(resolveName 先查这里——**同名 SHADOW core 内置**,
- * design/140 §6 1c 契约)。
- */
 import { TEAM_DISCUSSION_SCRIPT } from "@sema-agent/core";
 export function projectCollabToWorkflows(templates) {
     const out = { workflows: {}, skipped: [], notes: [] };
     for (const t of templates ?? []) {
         if (t.enabled === false)
-            continue; // 运营态关闭(不进 skipped)
+            continue;
         if (t.topology !== "ring" && t.topology !== "pair") {
             out.skipped.push({ id: t.id, reason: `topology "${t.topology}" awaits a dedicated profile (design/140 follow-on)` });
             continue;
@@ -47,17 +22,11 @@ export function projectCollabToWorkflows(templates) {
             out.skipped.push({ id: t.id, reason: "slot tools binding awaits the execution slice" });
             continue;
         }
-        // finalizer.slot → 脚本 finalizer(该席位退出讨论席)。slot **未配** ⇒ 脚本内置综合官兜底(合法形态);
-        // slot 配了但**悬空**(指向不存在的席位——拼错/编辑漂移)⇒ 整条跳过(静默回退默认综合官
-        // = 模板意图被悄悄改写,违「绝不静默降级」纪律;center zod 不做跨字段存在性校验,这里是唯一防线)。
         const finSlot = t.finalizer.slot !== undefined ? t.slots.find((s) => s.id === t.finalizer.slot) : undefined;
         if (t.finalizer.slot !== undefined && finSlot === undefined) {
             out.skipped.push({ id: t.id, reason: `finalizer.slot "${t.finalizer.slot}" does not match any slot id (dangling reference)` });
             continue;
         }
-        // 对抗评审 2026-07-11(MED):finalizer slot 合法可为 cardinality-N 多成员(registry-core 只约束
-        // cardinality=1 ≤1 人),但 team-discussion 的 finalizer 是单席——members[1..] 无席可坐。不静默丢人:
-        // 首成员任综合官,其余 note 上报(与 cap 截断同款有损注记纪律)。
         if ((finSlot?.members?.length ?? 0) > 1) {
             out.notes.push({ id: t.id, note: `finalizer slot "${finSlot.id}" carries ${finSlot.members.length} members — only the first seats as the synthesizer (single-seat finalizer profile)` });
         }
@@ -66,10 +35,6 @@ export function projectCollabToWorkflows(templates) {
         const finalizer = finPrompt !== undefined || finModel !== undefined
             ? { ...(finPrompt !== undefined ? { prompt: finPrompt } : {}), ...(finModel !== undefined ? { model: finModel } : {}) }
             : undefined;
-        // 讨论席展开(cardinality "N" 逐成员出席,role 序号唯一;member 镜头 > slot 镜头;T1 modelRef 缺省=
-        // 不设 model ⇒ 脚本/引擎跟随调用者当前模型,零特判)。members 为空的席位=slot 镜头即人设,一人出席。
-        // cardinality 声明与 members 实况分叉(=1 却配了多成员)不静默 flatten——全员照展开
-        // (丢成员=更糟的静默降级)但 note 上报,center 编辑面可据此标注修正。
         const members = [];
         for (const s of t.slots) {
             if (s === finSlot)
@@ -94,8 +59,6 @@ export function projectCollabToWorkflows(templates) {
             defaultArgs: { members, rounds: t.rounds.max, ...(finalizer ? { finalizer } : {}) },
             listing: {
                 name: t.id,
-                // description=center 起的显示名+描述(工具卡人话);whenToUse 留给 center 未来字段——缺席时
-                // 工具卡回落 description(core workflowWhenToUseText 链)。
                 description: [t.name, t.description].filter(Boolean).join(" — ") || t.id,
             },
         };
@@ -112,21 +75,15 @@ export function projectCollabToWorkflows(templates) {
     }
     return out;
 }
-// ── 模块级注册表(registerTeams 同款可变单例;applyEffective boot+refresh 热更,非粘:整表替换)────────
 let REGISTRY = {};
 export function registerCollabWorkflows(workflows) {
     REGISTRY = { ...workflows };
 }
-/** composite WorkflowScriptStore 的 resolveName 前段:collab 命中 ⇒ 内置 team-discussion 脚本+本模板
- *  defaultArgs(同名 SHADOW core 内置,design/140 §6 1c)。🔴 Object.hasOwn — `name` 是模型供给的
- *  (run-workflow-tool 原样传 rawName):裸索引会让 Object.prototype 成员名("constructor"/"toString"/
- *  "__proto__"…)假命中 ⇒ 零模板注册也能烧真讨论、且同名文件 store 条目被遮蔽(对抗评审 2026-07-11 MED)。 */
 export function resolveCollabWorkflow(name) {
     if (!Object.hasOwn(REGISTRY, name))
         return undefined;
     return { script: TEAM_DISCUSSION_SCRIPT, defaultArgs: REGISTRY[name].defaultArgs };
 }
-/** composite store 的 list() 段(同步——workflow 工具卡只吃同步 list,core 契约注释)。 */
 export function listCollabWorkflows() {
     return Object.values(REGISTRY).map((e) => e.listing);
 }

package/dist/capabilities/hands-lane.js

@@ -1,30 +1,8 @@
-/**
- * #196 场景 hands lane —— 「要手的场景」与「无手的场景」在装配层分家。
- *
- * 病根(设计小票 §1,案源 [3208]/[3209]/[3212]):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/…)。
- *
- * 本模块提供三件:
- *  ① {@link ScenarioHands} 判别位 + {@link pickHandsRunner} 的**穷举** switch —— 新场景不表态 = 编译红,
- *     不是静默继承 full(词表闭集纪律)。
- *  ② {@link HANDS_EXCLUSIVE_TOOL_NAMES} + {@link handsDenyPolicy} —— 纵深:hands=none 的任务即便被误接到
- *     有手 Runner 上,手独占名单逐一 deny。**不是**主保证(主保证是根本不挂 factory ⇒ 工具面不可见)。
- *  ③ {@link createHandsLaneRegistry} —— resolveSpec 产出 spec 与执行点选 Runner 之间的 lane 传递。
- */
 import { HAND_TOOL_EFFECTS, RETIRED_TOOL_NAMES, combinePolicies, createAllowDenyPolicy } from "@sema-agent/core";
-/**
- * 无手孪生 Runner 的 deps 构造:把 `executionEnvFactory` **摘键**(不是置 undefined)。
- * 摘键让「这只 Runner 没有手」在 deps 字面量上自证;置 undefined 留下一个值为 undefined 的键,
- * 与 core 现在的 `deps.executionEnvFactory ||` 判读结果相同,但把正确性寄托在真值判断上。
- */
 export function withoutExecutionEnv(deps) {
     const { executionEnvFactory: _handsDropped, ...rest } = deps;
     return rest;
 }
-/** 按场景表态取 Runner。**穷举 switch**:`ScenarioHands` 加词而此处不改 = 编译错(无 default 臂)。 */
 export function pickHandsRunner(hands, pair) {
     switch (hands) {
         case "full":
@@ -33,27 +11,6 @@ export function pickHandsRunner(hands, pair) {
             return pair.handsless;
     }
 }
-/**
- * core 手带 band 的工具名**全集** —— 「挂 executionEnvFactory 才出现、不挂就消失」的那一批。
- *
- * 两段来源,都不是拍脑袋:
- *  · `HAND_TOOL_EFFECTS`(core 导出面,`tools/fs`)—— band 的 effect 表,11 名。
- *  · 下方钉死补集 —— `createHandsToolkit` / 手带块还会铸但**不在** effect 表里的 5 名(实测差集,见
- *    test/scenario-hands-lane.test.ts 的对表格:它用真 Runner 跑「有手 roster ∖ 无手 roster」,与本常量逐名对账,
- *    core 加/改 band 成员时红,防漂移)。
- *
- * ⚠️ 本全集是**观测口径**(用于防漂移对账),**不是** deny 名单 —— deny 用下面的
- * {@link HANDS_EXCLUSIVE_TOOL_NAMES},理由见那里。
- *
- * 🚨 [3248] P0(2026-08-09):派生时必须过滤 core 的 `RETIRED_TOOL_NAMES` —— core 5.21.0 的
- * `HAND_TOOL_EFFECTS` 里残留已退役的 `MultiEdit`,而 core `prepare-task` 的策略名审计见退役名
- * **无条件 throw**(`config.legacy_tool_name`);不过滤,deny 名单一进 `spec.toolPolicy`,
- * `hands: none` 三场景(scan/code-review/team)在**所有部署**上零 turn 全灭。core 5.21.1 已删
- * 那条死条目([3249]),这道 filter 是结构性防御:将来 core 再退役任何 band 名都不会重演
- * (test/scenario-hands-lane.test.ts 格7/格8 双钉:真 Runner 过审计 + 零交集门)。
- * filter 打在**整表**(effect 表 + 钉死补集)之后 —— caret floor 下装置会解析到更新的 core,
- * 补集名哪天被退役,只滤前半就是同一次故障换个名字(codex 复审 finding,2026-08-09)。
- */
 export const HANDS_BAND_TOOL_NAMES = Object.freeze([
     ...Object.keys(HAND_TOOL_EFFECTS),
     "SendMessage",
@@ -62,37 +19,15 @@ export const HANDS_BAND_TOOL_NAMES = Object.freeze([
     "EnterWorktree",
     "ExitWorktree",
 ].filter((n) => !RETIRED_TOOL_NAMES.has(n)));
-/**
- * band 里**只有手才可能出现**的那批(= deny 名单)。
- *
- * 🔴 codex 复审(2026-08-09 finding-3,亲验 core prepare-task):band 全集里有四件是**两用**的 ——
- * `prepare-task` 的挂载条件是 `if (backgroundTaskToolsActive || workflowToolsActive)`,而
- * `workflowToolsActive` 只要 `spec.selfOrchestration`(caller 可设,与场景正交)+ 部署的 workflow deps
- * 就成立,**与手无关**。拿全集去 deny,会让「hands=none 场景 + selfOrchestration:true」的请求挂上
- * `Workflow` 却读不到它的轮询/停止/消息/转录 —— 一个半瘫的工作流面,比不给还糟。
- * 故 deny 名单 = 全集 ∖ 两用四件。Monitor 不在两用之列(core 的挂载条件是纯
- * `if (backgroundTaskToolsActive)`,而它 = handsIncludeShell ∧ …,无手不成立)。
- */
 export const HANDS_DUAL_USE_TOOL_NAMES = Object.freeze(["TaskOutput", "TaskStop", "SendMessage", "AgentTranscript"]);
 export const HANDS_EXCLUSIVE_TOOL_NAMES = Object.freeze(HANDS_BAND_TOOL_NAMES.filter((n) => !HANDS_DUAL_USE_TOOL_NAMES.includes(n)));
-/** 手独占名单的 deny 策略(纵深层)。名单是常量 ⇒ 每次调用产出等价策略,构造成本可忽略。 */
 export function handsDenyPolicy() {
     return createAllowDenyPolicy({ deny: [...HANDS_EXCLUSIVE_TOOL_NAMES] });
 }
-/**
- * 把 band deny 叠到既有基线上 —— **tighten-only**。
- *
- * 🪤 TRAP #1(runtime-governance.ts 头注逐字):`TaskSpec.toolPolicy` 是**覆盖**而非合并
- * (`spec.toolPolicy ?? deps.toolPolicy`),直接赋值会静默丢掉部署的 durable 审批基线 /
- * 单用户 auto-accept 座。走 `combinePolicies(base, deny)`(deny 胜、ask 不被 allow 冲掉),
- * 只会加 deny,永不放松。base 缺席时单挂 deny —— 该形下 band 本就不 mount,core 的
- * "write-capable hand tools are present but UNGATED" 信号不受影响(它以 Write 在场为条件)。
- */
 export function tightenWithHandsDeny(base) {
     const deny = handsDenyPolicy();
     return base ? combinePolicies(base, deny) : deny;
 }
-/** 装配点的取用形:`full` 原样放行基线,`none` 叠 deny。**穷举 switch**,无缺省臂。 */
 export function toolPolicyForHands(hands, base) {
     switch (hands) {
         case "full":

package/dist/capabilities/memory-notice.js

@@ -1,54 +1,13 @@
-/**
- * #217(板 [3499]②/[3521]④ 两次点名的 server 接线半场)—— 零记忆面部署形的**持久记忆披露**。
- *
- * 病(core [3479] 实测,#148 立案):一台没有任何持久记忆面的部署,用户说「请记住 X」,模型回一句
- * 「已经记住了」——落盘处并不存在。用户带着「这条事实已入库」的信念离开,下一次会话才发现是空的。
- *
- * core 5.26.0 的分工:引擎**能自证**只读的两态(engine 侧 `writeScope:null` / runner 侧 `handsReadOnly`)
- * 由引擎自动挂 `MEMORY_READONLY_NOTICE`;而「整台部署根本没有记忆面」这一形 core 只导出文本
- * (`NO_PERSISTENT_MEMORY_NOTICE`)、**不注入** —— 逐字原文:「A deployment that composes its own prompt
- * should include this block exactly when no memory face is mounted」。组装归宿主,与 `MEMORY_SAFETY`
- * 同姿势。本模块就是那半场。
- *
- * ⚠️ 两条边界,越界即双重注入/假话:
- *  · **engine 在场就不是我们的座位**。哪怕 `memoryWrite:false`(writeScope null)——那恰恰是引擎自己
- *    挂只读披露的状态,server 再叠一句口径不同的「你没有持久记忆」= 同一件事两种说法同框。
- *  · **推断到「有落盘路」就闭嘴**。判别式与 core 的 `rosterCanPersist` 同口径(已知落盘路 = 挂载且未
- *    排除的文件写工具 / 可写 shell)。⚠️ 名单确实要读(codex 复审 [medium] 之后加的 `excludeTools` 一位:
- *    roster 把落盘路**整批**卸掉时,手带在场也等于没有写通道),但负控仍然成立:必须**全部**已知落盘路
- *    都不在才算断链 —— `excludeTools:["Write"]` 不算(Bash/Edit 还在),请求面摘一个工具名改不动结论。
- */
 import { NO_PERSISTENT_MEMORY_NOTICE } from "@sema-agent/core";
 import { hasConstitutionAnchors } from "../task-settings.js";
-/**
- * 「已知落盘路」的工具名闭集 —— 与 core 的 `rosterCanPersist` 同口径:**文件写工具**(Write/Edit/
- * NotebookEdit)或**可写 shell**(Bash)。刻意**不是** `HAND_TOOL_EFFECTS` 里 effect=write 的全集:
- * core 逐字裁过「a generic write-effect tool does NOT count — a mail sender's side effect is not a
- * memory store」,`TaskStop` 就是那种(有写副作用、不是落盘路)。
- *
- * 名字会漂,所以配一道防漂移钉(test/no-persistent-memory-notice.test.ts):每个名字必须在 core 的
- * `HAND_TOOL_EFFECTS` 里且 effect 为 `write` —— core 改名/改档位当场红,而不是让这里静默失配成
- * 「没有一个写工具被排除」(fail-open 方向)。
- */
 export const KNOWN_PERSISTENCE_TOOL_NAMES = ["Write", "Edit", "NotebookEdit", "Bash"];
-/** 披露段在 `prompt.assembled` 清单里的段 id(`core/` 命名空间是 core 保留的,部署段一律自家前缀)。 */
 export const NO_PERSISTENT_MEMORY_SECTION_ID = "sema/memory.no-persistent";
-/** 排除后还剩不剩已知落盘路。空/缺席的排除名单 ⇒ 一定还剩(最常见的路径,提前短路)。 */
 function anyPersistenceToolSurvives(excludeTools) {
     if (excludeTools === undefined || excludeTools.length === 0)
         return true;
     const excluded = new Set(excludeTools);
     return KNOWN_PERSISTENCE_TOOL_NAMES.some((name) => !excluded.has(name));
 }
-/**
- * 该不该把 `NO_PERSISTENT_MEMORY_NOTICE` 组进本次任务的 system prompt。
- *
- * 优先序(每一条都有独立理由,不是同一条判据的三种写法):
- *  ① engine 在场 ⇒ **否**(引擎的座位,见文件头注);
- *  ② 部署显式声明 ⇒ 声明说了算(`true` 撤回 / `false` 强制)—— operator 的部署事实压过我们的推断,
- *     与 core 对 `memoryPersistenceCapable` 的处置同向;
- *  ③ 否则推断:有已知落盘路(手带在场且不是只读)⇒ 否;没有 ⇒ 是。
- */
 export function shouldDiscloseNoPersistentMemory(facts) {
     if (facts.memory !== undefined)
         return false;
@@ -56,46 +15,17 @@ export function shouldDiscloseNoPersistentMemory(facts) {
         return !facts.declaredCapable;
     if (facts.hands === "none" || facts.handsReadOnly)
         return true;
-    // remote 执行环境:手带写的是沙箱盘(每任务即焚),够不着任何 host 侧持久面 —— core 的
-    // `rosterCanPersist` 在这一形下把四只写工具**全部**不算,这里逐字同口径。
     if (facts.remoteExecutionEnv)
         return true;
-    // 手带在场,但 roster 可能把落盘路整批卸掉了(`excludeTools` 是真卸载)。⚠️ 负控仍成立:排掉**一个**
-    // `Write` 不算无写通道(Bash/Edit 还在)—— 必须**全部**已知落盘路都不在,才算这条链断了。
     return !anyPersistenceToolSurvives(facts.excludeTools);
 }
-/** 披露段作为独立 `behavior` 声明的形。**不能**用 `identity`:那个 slot 会替换 role base。 */
 const NOTICE_BLOCK = { id: NO_PERSISTENT_MEMORY_SECTION_ID, slot: "behavior", text: NO_PERSISTENT_MEMORY_NOTICE };
-/**
- * 把披露段挂进一组 typed 声明。两条腿,分界线是 core 装配器会走哪条臂:
- *  · 普通形 ⇒ 追加一条 `behavior` 声明(装配器正常 compose,段落各就各位);
- *  · 声明里有**已组装 identity**(三锚齐全)⇒ 装配器走 pass-through 臂:`roleBase = 该 identity 的文本`,
- *    其余声明**一条不挂**(core 只发一条「N 条声明未挂载」的告警)。此时追加 behavior 段等于什么都没做 ——
- *    披露判为真、模型侧一个字都收不到,正是 #148 要消灭的那种沉默。所以这一形改成把披露段接在**该 identity
- *    文本之后**(pass-through 臂原样把它当 `core/role.base` 发出去),文字真的进 prompt。
- *    ⚠️ `contentHash` 一并摘掉:文本被追加过就不再是 center 那份发布物的摘要,留着 = 一条对不上的对账锚
- *    (core 会为不匹配的摘要再发一条告警)。原文一个字节不改,只在后面接。
- */
 function mountNotice(decls) {
     const assembledIdentity = decls.find((d) => d.slot === "identity" && hasConstitutionAnchors(d.text));
     if (!assembledIdentity)
         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));
 }
-/**
- * 把披露段组进一个 prompt provider,**按 provider 自己的钩子形分腿**(换形会改段身份与 append 座位):
- *  · typed(`stableBlocks`)⇒ {@link mountNotice}(普通形追加 behavior 声明;已组装 identity 形接在其文本后)。
- *  · string(`stableSystem`)⇒ 接在 role 层文本之后(落进 `core/role.base` 段)。
- *  · 两个钩子都没有(= core 会用 `defaultPromptProvider`)⇒ **只发一条 typed 声明**,role 层留给 core 自己铸。
- *
- * ⚠️ 最后一腿为什么不是「自铸 role 层」(2026-08-12 复扫 medium,已实测):自铸形
- * `stableSystem: (ctx) => ${ctx.userSystemPrompt ?? DEFAULT_SYSTEM_PROMPT}\n\n${段落}` 把**调用方的**
- * systemPrompt 逐字变成了 provider 的输出。调用方传一份已组装 prompt(集成方/center 的常见形)时,装配器的
- * 迁移卫就在 provider 输出上探到三锚 ⇒ pass-through 臂 ⇒ 保留集无 `core/role.append` ⇒ 已被 append 门放行的
- * `appendSystemPrompt`/`settings.outputStyle` 静默蒸发(门在包装**之前**按未包装的 provider 判,两边分家)。
- * 走 typed 声明腿就没有这条耦合:role 层仍由 core 按 `userSystemPrompt ?? DEFAULT_SYSTEM_PROMPT` 自己铸,
- * 我方只贡献一条 behavior 段,`providerDropsAppend` 的判决包装前后逐格相同。
- */
 export function withNoPersistentMemoryNotice(provider) {
     if (provider?.stableBlocks) {
         const blocks = provider.stableBlocks.bind(provider);

package/dist/capabilities/prompt.js

@@ -1,17 +1,3 @@
-/**
- * Build a scenario's prompt provider from just its ROLE base, on core 1.243's 提示词主权 contract:
- * `stableSystem` returns ONLY the role layer (base + the task's own systemPrompt) and **core appends
- * the constitution structurally** — harness/safety blocks (Truth/CYBER_RISK/URL_SAFETY), mode blocks,
- * AND the memory safety/hygiene guidance (`constitutionBlocks`), plus the volatile `<user_memory>`
- * tail LAST (design/12 prefix-cache discipline; guarded in CI by `assertPromptCacheFriendly`).
- *
- * History: the pre-1.243 seam made this helper's whole-prompt replacement silently DROP
- * core's constitution — oa/code-review/team ran with zero safety blocks. Same batch also moved
- * MEMORY_SAFETY/MEMORY_HYGIENE into the constitution layer, so the hand-composition this helper used
- * to do (core 1.62, design/41) would now DOUBLE-inject them — both removed; core owns the discipline
- * (consolidation mutual-exclusion included). This stays a thin role-layer join so scenarios don't
- * re-implement the same two-line body five times.
- */
 export function stablePrompt(base) {
     return {
         stableSystem: ({ userSystemPrompt }) => [base, userSystemPrompt].filter(Boolean).join("\n\n"),

package/dist/capabilities/prompts/code-review.js

@@ -1,10 +1,3 @@
-/**
- * Code-review council copy (bundle-data layer). Pure data — placeholders are `{name}`-style,
- * filled by the consumer (code-review-council.ts fillPrompt). Guardrail rationale lives with the
- * consumer's comments; this file is ONLY the words.
- */
-/** The deployment-owned lens roster. Order = priority (security/correctness first = the bug-finders);
- *  the caller dials COUNT only (pickLenses), never a named subset. */
 export const REVIEW_LENSES = [
     { name: "security", brief: "authz/ownership checks, input validation, injection (SQL/command/path), secrets, unsafe deserialization, SSRF, trust boundaries" },
     { name: "correctness", brief: "edge cases, off-by-one, race conditions, resource leaks, missing/incorrect error paths, unhandled rejections" },
@@ -13,8 +6,6 @@ export const REVIEW_LENSES = [
     { name: "tests", brief: "are the risky paths covered? do tests assert behavior (not implementation)? missing edge-case tests" },
     { name: "readability", brief: "naming, dead code, duplication, misleading comments, structure — these are [DESIGN], never [BUG]" },
 ];
-/** Guardrails 2-5: evidence grounding (a CONFIDENCE signal, not a delete), requirement anchoring,
- *  bucketing, severity×confidence. */
 export const GROUNDING = [
     "RULES:",
     "1. EVIDENCE drives CONFIDENCE (it does NOT delete a finding): cite an exact `path:line` and, whenever you can, **paste the verbatim code snippet** you are flagging. A finding WITH a pasted snippet may carry full confidence/severity; a finding with only a line reference is still allowed but MUST be tagged `[unverified: line-ref only]` and capped at minor severity / low confidence (never a blocker).",
@@ -22,21 +13,17 @@ export const GROUNDING = [
     "3. BUCKET: label each finding [BUG] (provably wrong against the code), [DESIGN] (subjective preference), or [QUESTION]. A design preference is NEVER a [BUG].",
     "4. RATE each: severity (blocker/major/minor) AND confidence (high/med/low).",
 ].join("\n");
-/** L1 lens reviewer system prompt. Placeholders: {name} {brief} {grounding}. */
 export const LENS_SYSTEM_TPL = "You are a {name} code reviewer. Stay strictly in your lane: {brief}.\n" +
     "Read only the files you need — repo_tree to map, then repo_read_file (just-in-time).\n\n{grounding}\n\n" +
     'List findings in your lens only. If you find nothing solid, say "no findings".';
-/** L2 peer-debate persona (guardrails 5,6). Placeholders: {name} {brief}. */
 export const DEBATE_MEMBER_TPL = "You are the {name} reviewer on a review panel ({brief}). Cross-examine the findings in " +
     "the shared transcript: CORROBORATE or REBUT others' claims in your area (raising/lowering their " +
     "confidence), and DEFEND or WITHDRAW your own if rebutted.\n" +
     "You MAY call repo_read_file to VERIFY ONE specific DISPUTED finding (quote the exact path:line) — do " +
     "NOT re-review the whole repo. A finding with no path:line + code quote is invalid. Be concise.";
-/** L2 debate topic body. Placeholders: {objective} {grounding} {findings}. */
 export const DEBATE_TOPIC_TPL = "Cross-examine these specialist code-review findings for: {objective}\n\n{grounding}\n" +
     "5. CONFIDENCE: peer corroboration raises it; an unrebutted rebuttal lowers it; drop findings that " +
     "collapse under scrutiny.\n\nFindings to debate:\n\n{findings}";
-/** Guardrails 4,7: arbitration is not summary — no new findings, ground/dedup/bucket/rank only. */
 export const ARBITER_SYSTEM = "You are the NEUTRAL ARBITER of a code-review council. You are given findings from independent " +
     "specialist reviewers. You do NOT add new findings and do NOT re-review. Your only job:\n" +
     "- TIER by grounding, do NOT silently drop real findings: a finding that PASTES the code keeps its " +
@@ -48,6 +35,5 @@ export const ARBITER_SYSTEM = "You are the NEUTRAL ARBITER of a code-review coun
     "Output the final review: a 2-3 line summary, then findings grouped by bucket then severity, each as " +
     "`path:line` — the problem — a concrete fix. Never invent files or symbols. If a whole lens reported " +
     "nothing groundable, say so rather than inventing.";
-/** No-arbiter fallback header ({findings} appended by the consumer). */
 export const ARBITER_FALLBACK_HEADER = "[council 仲裁无输出——以下是未经仲裁的各 lens 原始发现]\n\n";
 //# sourceMappingURL=code-review.js.map