@jayyuen66/dsh-quality-gate 0.1.0

package/host.js

@@ -0,0 +1,1248 @@
+// GENERATED by build-host.mjs — edit host.ts / lib/*.ts, then run `node build-host.mjs`.
+import { closeSync, existsSync, openSync, readFileSync, readSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import Schema from "@deepseek-ai/schemastery";
+import { credentialRef, isCredentialRefName } from "@deepseek-ai/dsh-credentials";
+import { LOCALE_SETTINGS_NAMESPACE, messagesFor, resolveLocalePreference } from "@jayyuen66/dsh-plugin-shared/lib/locale";
+import { deriveProjectKey } from "@jayyuen66/dsh-plugin-shared/lib/project-key";
+import { editPathOf, scanToolEvents } from "@jayyuen66/dsh-plugin-shared/lib/tool-events";
+import { settleLessonCall } from "@jayyuen66/dsh-plugin-shared/lib/lesson-bus";
+import { fieldOf, isRecord } from "@jayyuen66/dsh-plugin-shared/lib/record";
+//#region lib/accumulator.ts
+/**
+* 需要过门禁的扩展名（代码与配置；md/txt/图片等免检）。
+*
+* **不含 `.sh`**：四种门禁命令（tsc / ruff / cargo / pnpm check）没有一个能校验 shell
+* 脚本，`.sh` 只会把根解析到最近的 package.json——`~/.dsh/run-all-tests.sh` 因此把门禁
+* 拖到用户主目录那个 `npm init` 空壳上跑出假失败（本机实测）。
+*/
+const GATED_EXT = /\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs|rs|py|json|ya?ml|toml)$/iu;
+/** 编辑类工具名。str_replace_editor 是 dsh-base 并存的另一套编辑器
+*  （host 侧只对 create/str_replace/insert 记账，view 只读不入这里）。 */
+const EDIT_TOOLS = /* @__PURE__ */ new Set([
+	"edit",
+	"write",
+	"str_replace_editor"
+]);
+const DEFAULT_MAX_FILES = 500;
+/** 回合内编辑文件累积器：note O(1)，drain 一次性取出并清空。 */
+var EditAccumulator = class {
+	files = /* @__PURE__ */ new Set();
+	maxFiles;
+	/** 容量淘汰累计丢弃数：drain 时清零（C10：500-cap 静默淘汰可观测）。 */
+	dropped = 0;
+	constructor(options = {}) {
+		this.maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+	}
+	/** 记一笔：编辑类工具 + 代码/配置扩展名 + 非空路径才收；容量淘汰时计数。 */
+	note(name, filePath) {
+		if (name === void 0 || !EDIT_TOOLS.has(name)) return;
+		if (typeof filePath !== "string" || filePath.length === 0) return;
+		if (!GATED_EXT.test(filePath)) return;
+		if (this.files.size >= this.maxFiles && !this.files.has(filePath)) this.evictOldest();
+		this.files.add(filePath);
+	}
+	/**
+	* 淘汰插入序最旧的一项并计数。调用点已保证集合非空（`size >= maxFiles >= 1`，本包
+	* maxFiles 只取默认 500 或测试里的 2），所以原意是**取首项这一次动作**，不是迭代——
+	* 旧写法拿 `for…of` + 无条件 `break` 伪装单次取值，那正是 eslint(no-unreachable-loop)
+	* 判的「循环体只允许一次迭代」：循环结构在这里没有承载任何语义。改成直接取首个元素，
+	* 单次淘汰的行为（删最旧 + 计数）与原样一致。
+	*/
+	evictOldest() {
+		const [oldest] = this.files;
+		if (oldest === void 0) return;
+		this.files.delete(oldest);
+		this.dropped += 1;
+	}
+	/** 自上次 drain 以来容量淘汰丢弃的文件数（C10：>0 时 host 侧 console.warn）。 */
+	droppedCount() {
+		return this.dropped;
+	}
+	/** 取出全部去重文件并清空（Stop 批处理后调用；重复调用得空表；同时清零淘汰计数）。 */
+	drain() {
+		const out = [...this.files];
+		this.files.clear();
+		this.dropped = 0;
+		return out;
+	}
+};
+//#endregion
+//#region lib/gate-detect.ts
+/**
+* `pnpm check` 是否可用：必须有已声明的 check 脚本，**信息缺失时一律判否**。
+*
+* 为什么取保守方向（宁可不给门禁，也不发这条命令）：没有声明 `check` 的 pnpm 工程
+* 是绝大多数，`pnpm check` 会以「Command "check" not found」非零退出；而本包把门禁
+* 失败当**真实质量缺陷**处理——开新回合注入"修这些错"、写 lesson-loop 总线、可选写
+* 记忆环。于是对一个代码本来就没问题的使用者，这是一条稳定复现的假失败注入。
+* 反方向的代价只是"这个根本轮没有自动核验"（读不到 package.json 的工程本就少见），
+* 用户可以自己跑检查。两害相权：**假失败比漏检查更贵**。
+*/
+function pnpmCheckReady(scripts) {
+	return scripts?.includes("check") === true;
+}
+/** 从 ProjectRoot（根目录相对名清单 + 已声明脚本）判定单根门禁。 */
+function gateForRoot(entry) {
+	const { root, files, scripts } = entry;
+	const has = (name) => files.includes(name);
+	let gate;
+	if (has("pnpm-workspace.yaml") && has("package.json") && pnpmCheckReady(scripts)) gate = {
+		root,
+		command: ["pnpm", "check"]
+	};
+	else if (has("Cargo.toml")) gate = {
+		root,
+		command: ["cargo", "check"]
+	};
+	else if (has("pyproject.toml") || has("ruff.toml")) gate = {
+		root,
+		command: [
+			"ruff",
+			"check",
+			"."
+		]
+	};
+	else if (has("package.json") && has("tsconfig.json")) gate = {
+		root,
+		command: [
+			"npx",
+			"tsc",
+			"--noEmit"
+		]
+	};
+	return gate;
+}
+/** 多根归并探测：每个根独立判定，无清单的根跳过（返回 undefined）。 */
+function detectGate(roots) {
+	const out = [];
+	for (const entry of roots) {
+		const gate = gateForRoot(entry);
+		if (gate !== void 0) out.push(gate);
+	}
+	return out;
+}
+//#endregion
+//#region lib/messages.ts
+const MESSAGES = {
+	zh: {
+		evidenceTruncated: "[证据截断] {label} 内存里只保留尾部（首个错误可能在被丢弃的头部）。完整输出：{spill}",
+		noSpillFile: "无落盘文件",
+		evidenceHeadTail: "—— 头部摘录（根因多在此）——\n{head}\n—— 尾部 ——\n{text}",
+		gateFailed: "[quality-gate] 回合收口门禁未通过（{command}，根 {root}）：\n{output}\n请修复上述问题后结束回合。不要重做已完成的工作，只修门禁报出的错误。",
+		gateNotRun: "[quality-gate] 回合收口门禁**未能执行**（{command}，根 {root}）：\n{reason}\n这不是代码错误的证据：**不要为此修改代码**，也不要把它当成已通过。请在结束本回合前手动运行该命令确认代码健康，或向用户说明门禁无法执行的原因。",
+		gaveUp: "[quality-gate] 已自动注入 {attempts} 次修复指令，门禁（{command}，根 {root}）仍未通过。为避免无限消耗 token，本轮停止自动修复并放行。请手动运行该命令确认代码健康；若确需修复，请明确告知用户需要人工介入，不要反复重试同一门禁。",
+		gatesSkipped: "剩余预算不足 {budgetMs}ms，以下门禁本轮未执行：\n{list}\n这些根的代码健康**尚未核验**，不要把它们当已通过。",
+		skippedGateItem: "- {command}（根 {root}）",
+		sandboxMode: "沙箱模式={mode}",
+		sandboxEnforcement: "，enforcement={enforcement}",
+		runnerFailed: "沙箱 runner 启动失败，命令根本没跑（{sandbox}）。",
+		policyDenied: "沙箱策略拒绝了对门禁工作目录的写入（{sandbox}）：命令未获准真正执行。",
+		timedOut: "exit=timeout（{seconds}s 预算内未完成），门禁未得到结果。",
+		aborted: "门禁执行被调用方取消（aborted），结果未知。",
+		toolMissing: "命令不存在（工具未安装）",
+		toolNotExecutable: "命令不可执行",
+		toolNotRun: "{cause}，门禁没有运行。",
+		toolStub: "门禁工具本身不可用（npx 抓到的是 stub 包，不是真工具）。",
+		policyUnresolvable: "沙箱策略无法解析（{message}），门禁拒绝在未确认的沙箱边界下执行。",
+		sandboxUnavailable: "沙箱在本机不可用（{message}）：命令被拒绝执行，未做任何检查。",
+		gateStartFailed: "门禁未能启动（{message}）。",
+		memoryFeedback: "[quality-gate 反馈] 门禁失败 {command}（根 {root}）：{failure}"
+	},
+	en: {
+		evidenceTruncated: "[evidence truncated] only the tail of {label} is kept in memory (the first error may be in the dropped head). Full output: {spill}",
+		noSpillFile: "no spill file",
+		evidenceHeadTail: "—— head excerpt (root cause usually here) ——\n{head}\n—— tail ——\n{text}",
+		gateFailed: "[quality-gate] the turn-end quality gate did not pass ({command}, root {root}):\n{output}\nFix the problems above before ending the turn. Do not redo work that is already done — fix only what the gate reported.",
+		gateNotRun: "[quality-gate] the turn-end quality gate **could not run** ({command}, root {root}):\n{reason}\nThis is not evidence of a code error: **do not change code because of it**, and do not treat it as passed. Run that command manually before ending the turn to confirm the code is healthy, or tell the user why the gate could not run.",
+		gaveUp: "[quality-gate] {attempts} repair instructions were injected automatically and the gate ({command}, root {root}) still does not pass. To avoid burning tokens forever, automatic repair stops here and this turn is released. Run the command manually to confirm the code is healthy; if a fix really is needed, tell the user explicitly that human intervention is required instead of retrying the same gate.",
+		gatesSkipped: "Less than {budgetMs}ms of budget remains, so these gates did not run this turn:\n{list}\nThe code health of these roots **has not been verified** — do not treat them as passed.",
+		skippedGateItem: "- {command} (root {root})",
+		sandboxMode: "sandbox mode={mode}",
+		sandboxEnforcement: ", enforcement={enforcement}",
+		runnerFailed: "The sandbox runner failed to start, so the command never ran ({sandbox}).",
+		policyDenied: "The sandbox policy denied writes to the gate's working directory ({sandbox}): the command was never allowed to actually run.",
+		timedOut: "exit=timeout (not finished within the {seconds}s budget), the gate got no result.",
+		aborted: "Gate execution was cancelled by the caller (aborted); the result is unknown.",
+		toolMissing: "command not found (tool not installed)",
+		toolNotExecutable: "command not executable",
+		toolNotRun: "{cause} — the gate did not run.",
+		toolStub: "The gate tool itself is unavailable (npx fetched a stub package, not the real tool).",
+		policyUnresolvable: "The sandbox policy could not be resolved ({message}); the gate refuses to run under an unconfirmed sandbox boundary.",
+		sandboxUnavailable: "The sandbox is unavailable on this machine ({message}): the command was denied and no check was performed.",
+		gateStartFailed: "The gate failed to start ({message}).",
+		memoryFeedback: "[quality-gate feedback] gate failure {command} (root {root}): {failure}"
+	}
+};
+/** 渲染模板里的 {name} 占位符；未提供的名字留空串（宁可少一段说明，也不给模型留裸花括号）。
+*  与 client 半官方 `@deepseek-ai/dsh-client-locale` 的 Translate 插值同语义（宿主同规则）。
+*  @param text - 字典里的整行模板。
+*  @param params - 占位符名 → 值（数字会转成字符串）。
+*  @returns 替换后的文本。
+*/
+function renderTemplate(text, params) {
+	return text.replaceAll(/\{(?<key>\w+)\}/gu, (_all, key) => {
+		const value = params[key];
+		return value === void 0 ? "" : String(value);
+	});
+}
+//#endregion
+//#region lib/feedback-content.ts
+/** 门禁失败 → 记忆正文：单行化（防换行噪音）。
+*  去截断（用户拍板"不为省 token 降能力"）：旧实现 400 字符截尾会把
+*  多根错误的中间根因吃掉；记忆网关的入库限额由网关侧把关，这里送全文。
+*  正文语言随官方 locale 偏好走（messages 由调用方按回合取出后传进来）——这条文本会被
+*  auto-recall 注入后续会话的上下文，是模型读的，不是日志。 */
+function buildFeedbackText({ command, root, failure }, messages) {
+	const cmd = command.join(" ");
+	const tail = failure.replaceAll(/\s+/gu, " ").trim();
+	return renderTemplate(messages.memoryFeedback, {
+		command: cmd,
+		root,
+		failure: tail
+	});
+}
+//#endregion
+//#region lib/gateway-target.ts
+/** env 值 trim 后非空则用之，否则回到 fallback（保留原 `||` 语义，
+*  又以显式比较规避 prefer-nullish-coalescing 与 strict-boolean-expressions）。 */
+function envOr(key, fallback) {
+	const trimmed = process.env[key]?.trim();
+	return trimmed !== void 0 && trimmed !== "" ? trimmed : fallback;
+}
+/**
+* 网关基址：设置值优先，留空时回落到 TDAI_GATEWAY_URL（逃生门），**两处都空则为空串**。
+* 空串即"未配置"——调用方据此不启用记忆反馈。默认值不再是任何人的本机地址
+* （旧实现把作者机器上的 http://127.0.0.1:8420 写死成默认，别人每次门禁失败都去连一个
+* 不存在的服务）。设置优先于 env 的理由：设置卡是用户显式配置面，env 只能兜底，
+* 否则用户改了设置卡仍被一个看不见的环境变量越权。
+*/
+function resolveGatewayUrl(settingUrl) {
+	const configured = settingUrl.trim();
+	return (configured === "" ? envOr("TDAI_GATEWAY_URL", "") : configured).replace(/\/+$/u, "");
+}
+/** x-tdai-service-id：env 可覆盖，默认是网关协议的匿名服务名（不含任何机器信息）。 */
+function resolveServiceId() {
+	return envOr("TDAI_SERVICE_ID", "default");
+}
+/** cwd → agent_id：'尾目录名-<cwd 前 8 位 sha256>'（与网关插件 workspace-peer 同分桶语义，
+* 读/写同键，保证反馈沉淀进 auto-recall 同一记忆桶）。
+* 派生本体在 shared/lib/project-key.ts：lesson-loop 的 project 与这里同源一份实现，
+* 此前两处各存一份，改一处漏一处就把"教训 ↔ 记忆"的跨系统对照拆断了。 */
+function deriveAgentId(cwd) {
+	return deriveProjectKey(cwd);
+}
+//#endregion
+//#region lib/gateway-feedback.ts
+/** 反馈尽力而为：5s 封顶，超时/失败只 warn（不吃掉门禁主流程）。 */
+const FEEDBACK_TIMEOUT_MS = 5e3;
+/** 沉淀门禁失败到 L0 记忆（role=assistant：这是 agent 自身行为教训，归顺 assistant 提炼面）。 */
+async function pushGateFeedback(input, target, messages) {
+	const agentId = deriveAgentId(input.cwd);
+	const content = buildFeedbackText(input, messages);
+	const payload = JSON.stringify({
+		session_id: "dsh-agent",
+		agent_id: agentId,
+		messages: [{
+			role: "assistant",
+			content
+		}]
+	});
+	const res = await fetch(`${target.url}/v2/conversation/add`, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${target.key}`,
+			"x-tdai-service-id": resolveServiceId(),
+			"Content-Type": "application/json"
+		},
+		body: payload,
+		signal: AbortSignal.timeout(FEEDBACK_TIMEOUT_MS)
+	});
+	if (!res.ok) throw new Error(`gateway feedback HTTP ${res.status}`);
+	await res.arrayBuffer().catch(() => null);
+}
+//#endregion
+//#region host.ts
+/**
+* 常见项目根标记文件：向上找最近的含清单目录。
+* ruff.toml 必须在列（审计 LOW-MED 项）：只有 ruff 配置、无 pyproject.toml 的 Python
+* 工程若不在此登记，gate-detect 的 has("ruff.toml") 就是死码——那类工程根本得不到根，
+* 也就永远没有门禁。
+*/
+const MANIFESTS = [
+	"package.json",
+	"Cargo.toml",
+	"pyproject.toml",
+	"pnpm-workspace.yaml",
+	"ruff.toml"
+];
+/** 本插件 followup 注入消息的 producer-owned source.kind（session-rescue 的
+*  RESCUE_SOURCE_KIND 同款）。0.1.7 的 V4 准入拒收退役包装
+*  `{ kind: 'plugin', plugin }`（session-format-v3-to-v4/src/message-sources.ts
+*  对每个声明的持久消息位抛 "format v4 message requires a producer-owned source
+*  kind"，followup 经 inbox 落 `agent/inbox/spliced`，正是被拒的持久位）；
+*  迁移表把未知插件名统一加 `plugin:` 前缀（sources.ts producerKind），故本插件
+*  已迁移的历史行读回也是同一个串——发出同一串，新行与历史行才是同一个身份。 */
+const GATE_SOURCE_KIND = "plugin:quality-gate";
+/**
+* "门禁跑了且报了代码错误"这一态的 kind 值（注入分流与 lesson 总线 category 都读它）。
+* 判别联合的类型面经 `typeof` 绑同一处，避免字面量两处各自漂移。
+*/
+const GATE_KIND_CODE_FAILURE = "code-failure";
+/** 设置面（= profile 条目 `quality-gate` 的可编辑表单）与 loader 行 config 共用同一份
+*  schema（单源，防漂移）。六个字段**全部** `.volatile()`：没有任何 volatile 字段的条目
+*  会被宿主 describe() 整条跳过（packages/settings/settings/src/index.ts:308-309），
+*  写入则抛 `has no volatile fields`（:386）。
+*  两个策略陷阱（都锁在下面对应的行内注释里，改默认前先读）：
+*   - `memoryGatewayUrl` 的默认是**空串**而不是缺省：`""` + feedback-off = 永不推送，
+*     换成 undefined 会把"未配置"变成"字段不存在"，行为不再等价；
+*   - `memoryGatewayKeyRef` 的 `.role('credential-ref')` 与 `.volatile()` **共存**：role 只
+*     写 meta.role（fork 的 role/volatile 都是 `{...meta, k: v}` 展开，见
+*     vendor/schemastery/src/index.ts:463-482），不会抹掉 meta.volatile。 */
+const Config = Schema.object({
+	enabled: Schema.boolean().default(true).volatile(),
+	maxInjectsPerTurn: Schema.natural().min(1).max(5).default(2).volatile(),
+	gateBudgetMs: Schema.natural().min(1e4).max(6e5).default(3e5).volatile(),
+	memoryFeedback: Schema.boolean().default(false).volatile(),
+	memoryGatewayUrl: Schema.string().default("").volatile(),
+	memoryGatewayKeyRef: Schema.string().role("credential-ref").default("TDAI_GATEWAY_KEY").volatile(),
+	/** 向上找项目根的最大层数（深嵌套 monorepo 的探测深度）。 */
+	maxRootDepth: Schema.natural().default(10),
+	/** 门禁 stdout 捕获上限（字节）：超过则 harness 只保留尾部（见 CollectedOutput）。 */
+	gateStdoutMaxBytes: Schema.natural().default(65536)
+});
+/** 总预算尾段的最小可用门预算：低于此值再跑门禁必然超时（假失败），跳过剩余门禁。 */
+const MIN_USEFUL_GATE_MS = 5e3;
+/** 截断证据的头部摘录上限（字节）：从 spill 文件里**有界**读回开头（根因所在）。 */
+const EVIDENCE_HEAD_BYTES = 4096;
+/** harness SandboxUnavailableError 的错误码（run() 抛出即"命令根本没跑"）。 */
+const SANDBOX_UNAVAILABLE = "SANDBOX_UNAVAILABLE";
+/** 会话级 Map 的条数上限：超限按插入序淘汰最旧（防长期运行进程无界增长）。 */
+const SESSION_BUDGET = 50;
+/** 从 unknown 安全读字段：字面量键走变量参数，绕开 dot-notation 与
+*  noPropertyAccessFromIndexSignature（tsc 禁索引签名点访问）的互斥。 */
+/** 错误摘要（String(error) 对非 Error 会打出 [object Object]，这里显式分类）。 */
+function messageOf(error) {
+	let message = "unknown error";
+	if (error instanceof Error) ({message} = error);
+	else if (typeof error === "string") message = error;
+	return message;
+}
+/**
+* 会话级 Map 淘汰：把 keep 先删后插移到队尾（JS Map 迭代按插入序），再淘汰队首
+* (size - 50) 项 → keep 永不被淘汰，且总大小收敛。泛型复用：注入配额 Map（InjectState）、
+* 事件游标 Map（number）与编辑累加器 Map（EditAccumulator）共用同一策略。
+* keep 不在表内 → 直接返回（inbox-busy 分支的 injectState 就会命中：该会话从未失败过）。
+*/
+function pruneToSessionBudget(map, keep) {
+	const kept = map.get(keep);
+	if (kept === void 0) return;
+	map.delete(keep);
+	map.set(keep, kept);
+	let excess = map.size - SESSION_BUDGET;
+	for (const key of map.keys()) {
+		if (excess <= 0) break;
+		map.delete(key);
+		excess -= 1;
+	}
+}
+/**
+* 根会话判定（与 ctx-observe/lesson-loop 同款口径）：子代理会话
+* （delegationDepth>0 或 origin==='subagent'）跳过门禁。
+*
+* agent/turn-stopping 对每个 agent（含 in-process fork/spawn 子代理）都触发，
+* 旧实现未过滤子代理 → ①父会话与子代理对同一项目根各跑一遍门禁（token/耗时翻倍）；
+* ②失败注入文案面向用户，却 followup 进子代理——结算前到达会多拖一轮子代理回合，
+* 结算后到达则滞留 inbox 被丢弃（门禁静默失效）。统一改为只对根会话收口。
+*
+* out-of-process 子代理（ACP/claude-code/codex）
+* 在独立进程运行，不发射 dsh 的 agent 事件，其编辑天然不在任何门禁面内；in-process
+* 子代理经本判定跳过后，其编辑由父会话下一回合的收口门禁在父侧统一核验（未来如需
+* 精确到子代理编辑，可在父会话聚合子会话 tool/call——本插件不做，避免过度设计）。
+*/
+function isRootSession(agent) {
+	const { header } = agent.session;
+	return !((header.delegationDepth ?? 0) > 0 || header.origin === "subagent");
+}
+/** Inbox 是否有待处理消息（读面 = `InboxQueues`：两位队列都可能缺席，故 `?.length ?? 0`）。 */
+function inboxHasPending(inbox) {
+	return (inbox.nextTurn?.length ?? 0) > 0 || (inbox.nextStep?.length ?? 0) > 0;
+}
+/**
+* 触发前二次校验：turn-stopping 时 agent.status 恒为 'running'
+* （官方 agent.ts：turn-stopping 在 running 相内 serial 分发，转 idle 发生在回合结束之后），
+* 故绝不能用 status 判 idle。改用数据信号：turn signal 已取消、或 inbox 有待处理
+* （用户接管/已排队工作）→ 不注入（对齐官方 "Data decides" 语义）。
+* 插件卸载的拦截不在这里：W4 起 disposer abort 在飞门禁批次，迟到结果在批次层就地丢弃
+* （见 processGate），到不了注入点——卸载收口比"注入前拦一下"更强。
+*/
+function preInjectCheck(agent, signal) {
+	if (signal?.aborted === true) return {
+		ok: false,
+		reason: "turn aborted"
+	};
+	if (inboxHasPending(agent.inbox)) return {
+		ok: false,
+		reason: "inbox busy"
+	};
+	return {
+		ok: true,
+		reason: "ready"
+	};
+}
+/**
+* 判定门禁失败是否为"工具本身不可用"（而非代码问题）。
+*
+* `npx tsc` 在项目未装 typescript 时会**自动安装**已弃用的 stub 包 `tsc@2.0.4`，
+* 它打印横幅并以 exit 1 退出——不是 126/127，所以只按退出码判定会误报为代码失败。
+* 实测：`npx --no-install` 在本机拦不住 stub（已从 npx 缓存解析），
+* 所以必须在输出侧识别，不能只靠加 flag。
+*/
+function gateToolUnavailable(stdout, stderr) {
+	const out = `${stdout}\n${stderr}`.toLowerCase();
+	if (out.includes("not the tsc command you are looking for")) return true;
+	return out.includes("npm warn deprecated tsc@");
+}
+/** harness run() 抛出的 SandboxUnavailableError（code 或 name 命中即可）。 */
+function isSandboxUnavailable(error) {
+	return fieldOf(error, "code") === SANDBOX_UNAVAILABLE || fieldOf(error, "name") === "SandboxUnavailableError";
+}
+/**
+* 有界读取截断落盘文件的头部（首个错误通常在开头，而 harness 只把尾部留在内存里；
+* spill 文件可达数 MB，故用 openSync/readSync 只读前 EVIDENCE_HEAD_BYTES）。
+* 不可读（无权限/已回收/非绝对路径）→ undefined：调用方只标注截断，不伪造头部。
+*/
+function headExcerpt(file) {
+	let excerpt;
+	if (file !== void 0 && path.isAbsolute(file)) try {
+		const fd = openSync(file, "r");
+		try {
+			const buffer = Buffer.alloc(EVIDENCE_HEAD_BYTES);
+			const bytesRead = readSync(fd, buffer, 0, EVIDENCE_HEAD_BYTES, 0);
+			excerpt = buffer.subarray(0, bytesRead).toString("utf8");
+		} finally {
+			closeSync(fd);
+		}
+	} catch {
+		excerpt = void 0;
+	}
+	return excerpt;
+}
+/**
+* 证据文本。
+*
+* tsc/cargo 等错误自顶向下，**首条才是根因**，而 harness CollectedOutput 截断时保留的是
+* **尾部**（packages/subprocess/src/types.ts）——旧实现从不查 truncated，根因错误被静默
+* 丢掉，注入给模型的"修这些错"只剩残尾（审计 MEDIUM 项）。现在：
+*   ①显式标注截断；②从 spillPath 有界读回头部摘录放在最前；③无落盘文件时明确说明
+*   首个错误可能已丢弃，让模型与用户都知道证据不完整。
+* 未截断时不叠加第二层截断（用户拍板"不为省 token 降能力"，上限由 shell 的
+* stdoutMaxBytes 把关）。
+*/
+function evidenceText(messages, stream, label) {
+	if (!stream.truncated) return `${label}:\n${stream.text}`;
+	const head = headExcerpt(stream.spillPath);
+	const notice = `${renderTemplate(messages.evidenceTruncated, {
+		label,
+		spill: stream.spillPath ?? messages.noSpillFile
+	})}\n`;
+	let out = `${notice}${stream.text}`;
+	if (head !== void 0) out = `${notice}${renderTemplate(messages.evidenceHeadTail, {
+		head,
+		text: stream.text
+	})}`;
+	return out;
+}
+const gateText = (messages, gate, out) => renderTemplate(messages.gateFailed, {
+	command: gate.command.join(" "),
+	root: gate.root,
+	output: out
+});
+/**
+* "门禁没跑成"文案：与"修这些错"严格分开——没跑成的检查不是代码错误的证据，
+* 让模型去修一个装不上的工具/越不过去的沙箱，只会配着配额环烧 token。
+*/
+const notRunText = (messages, gate, reason) => renderTemplate(messages.gateNotRun, {
+	command: gate.command.join(" "),
+	root: gate.root,
+	reason
+});
+/** 配额耗尽后的"放行说明"（用户可见，不再静默 return）。 */
+const giveUpText = (messages, gate, attempts) => renderTemplate(messages.gaveUp, {
+	attempts,
+	command: gate.command.join(" "),
+	root: gate.root
+});
+/** 未执行清单的一行（模块级：不让 renderTemplate 套进 map 再套进 renderTemplate）。 */
+const skippedGateLine = (messages, gate) => renderTemplate(messages.skippedGateItem, {
+	command: gate.command.join(" "),
+	root: gate.root
+});
+/** 预算耗尽后剩余门禁的"未执行"清单（审计 MEDIUM 项：只 warn = 静默通过）。 */
+const skippedText = (messages, gates) => renderTemplate(messages.gatesSkipped, {
+	budgetMs: MIN_USEFUL_GATE_MS,
+	list: gates.map((gate) => skippedGateLine(messages, gate)).join("\n")
+});
+/** 沙箱事实 → 可读的模式/完备度说明（策略拒绝与代码失败分开表述的素材）。 */
+function sandboxNote(messages, facts) {
+	const mode = renderTemplate(messages.sandboxMode, { mode: facts.mode });
+	return facts.enforcement === void 0 ? mode : `${mode}${renderTemplate(messages.sandboxEnforcement, { enforcement: facts.enforcement })}`;
+}
+/**
+* 沙箱面拦截结论（runner 不可用 / 策略拒绝）→ not-run。
+*
+* 两条消息按官方事实的优先级二选一（runnerFailed 先），判定序与旧内联 if 完全一致；
+* 没有拦截返回 undefined，交给退出码阶梯。
+*/
+function sandboxBlockOutcome(messages, facts, stderr) {
+	let outcome;
+	if (facts.runnerFailed === true || facts.denied) {
+		const sandbox = sandboxNote(messages, facts);
+		outcome = {
+			kind: "not-run",
+			text: `${facts.runnerFailed === true ? renderTemplate(messages.runnerFailed, { sandbox }) : renderTemplate(messages.policyDenied, { sandbox })}\n${evidenceText(messages, stderr, "stderr")}`
+		};
+	}
+	return outcome;
+}
+/**
+* 进程没跑完的三种形态：超时 / 取消 / 没有退出码（被信号杀死）。
+*
+* 前两条按 not-run，被信号杀死按代码失败——与旧 ladder 的前三支同序同文案。
+*/
+function interruptedRunOutcome(messages, budgetMs, res) {
+	let outcome;
+	if (res.timedOut) outcome = {
+		kind: "not-run",
+		text: `${renderTemplate(messages.timedOut, { seconds: Math.round(budgetMs / 1e3) })}\n${evidenceText(messages, res.stdout, "stdout")}${evidenceText(messages, res.stderr, "stderr")}`
+	};
+	else if (res.aborted) outcome = {
+		kind: "not-run",
+		text: messages.aborted
+	};
+	else if (res.exitCode === null) {
+		const signalName = typeof res.signal === "string" && res.signal.length > 0 ? res.signal : "?";
+		outcome = {
+			kind: GATE_KIND_CODE_FAILURE,
+			text: `exit=signal(${signalName})\n${evidenceText(messages, res.stdout, "stdout")}${evidenceText(messages, res.stderr, "stderr")}`
+		};
+	}
+	return outcome;
+}
+/**
+* 门禁工具本身不可用（exit 126/127 = 不可执行/未找到）→ not-run，并 warn 给运维。
+*
+* 环境问题非代码问题：走失败注入会让模型去"修"装不了的工具（配合配额环更糟）。
+* 但它同样是"没跑成的检查"，所以按 not-run 注入"请手动确认"，不再算作通过
+* （审计：没跑成 ≠ 通过）。
+*/
+function unavailableToolOutcome(messages, gate, res, log) {
+	let outcome;
+	if (res.exitCode === 126 || res.exitCode === 127) {
+		log.warn(`[quality-gate] gate tool unavailable (exit ${res.exitCode}): ${gate.command.join(" ")} — reported as not-run, not as pass`);
+		const cause = res.exitCode === 127 ? messages.toolMissing : messages.toolNotExecutable;
+		outcome = {
+			kind: "not-run",
+			text: `${renderTemplate(messages.toolNotRun, { cause })}\n${evidenceText(messages, res.stderr, "stderr")}`
+		};
+	}
+	return outcome;
+}
+/**
+* 把一次 shell.execute().result() 结果分类成三态（纯函数：不进 ctx，每条分支都可测）。
+*
+* harness 的 ShellRunResult.sandbox 与退出码**正交**上报（packages/shell/shell/src/types.ts：
+* "Facts are reported independently of process exit status so callers can distinguish
+* command failures from policy denials and runner failures"），旧实现从不读它 →
+* 策略拒绝被当成代码失败注入"修这些错"（审计 HIGH 项）。
+*
+* 判定序（三支各自成函数，顺序与 warn 次数都不变）：沙箱面拦截 → 进程没跑完 →
+* 工具装不上（126/127）→ exit 0（部分生效沙箱只 warn）→ npx stub 横幅 → 代码失败。
+*/
+function classifyRun(messages, gate, budgetMs, res, log) {
+	const facts = res.sandbox;
+	if (facts !== void 0) {
+		const blocked = sandboxBlockOutcome(messages, facts, res.stderr);
+		if (blocked !== void 0) return blocked;
+	}
+	const interrupted = interruptedRunOutcome(messages, budgetMs, res);
+	if (interrupted !== void 0) return interrupted;
+	const unusable = unavailableToolOutcome(messages, gate, res, log);
+	if (unusable !== void 0) return unusable;
+	if (res.exitCode === 0) {
+		if (facts?.enforcement === "partial") log.warn(`[quality-gate] gate passed under PARTIAL sandbox enforcement (${sandboxNote(messages, facts)}): ${gate.command.join(" ")} @ ${gate.root}`);
+		return { kind: "pass" };
+	}
+	if (gateToolUnavailable(res.stdout.text, res.stderr.text)) {
+		log.warn(`[quality-gate] gate tool unavailable (npx fetched a stub instead of the real tool): ${gate.command.join(" ")} in ${gate.root} — reported as not-run`);
+		return {
+			kind: "not-run",
+			text: `${messages.toolStub}\n${evidenceText(messages, res.stderr, "stderr")}`
+		};
+	}
+	return {
+		kind: GATE_KIND_CODE_FAILURE,
+		text: `exit=${res.exitCode}\n${evidenceText(messages, res.stdout, "stdout")}${evidenceText(messages, res.stderr, "stderr")}`
+	};
+}
+/** 是否是会被记账的编辑类工具（edit/write + str_replace_editor）。 */
+function isEditTool(name) {
+	return name === "edit" || name === "write" || name === "str_replace_editor";
+}
+/**
+* 根 package.json 已声明的 scripts 名清单（值是非空字符串才算"声明了这条脚本"）。
+*
+* 读不到 / JSON 非法 / 没有 scripts 字段 → **undefined（"没有信息"）**，由 gate-detect
+* 按保守口径处理（不发 pnpm check）。不在这里替项目猜：猜错的代价是假失败注入。
+*/
+function declaredScriptsOf(root) {
+	let names;
+	try {
+		const raw = JSON.parse(readFileSync(`${root}/package.json`, "utf8"));
+		const scripts = fieldOf(raw, "scripts");
+		if (isRecord(scripts)) names = Object.entries(scripts).filter(([, body]) => typeof body === "string" && body.length > 0).map(([name]) => name);
+	} catch {
+		names = void 0;
+	}
+	return names;
+}
+/** 数组性判据（**不是** type predicate，故不产生类型收窄；理由见 resolveEventWindow）。 */
+function isArrayDelivery(value) {
+	return Array.isArray(value);
+}
+/**
+* 解析事件游标窗口：fork 切点下限 vs 上次已读 seq 取大，返回起始 seq 与本批事件。
+* 事件流取自官方 `ctx.sessionQuery.observeSession(sessionId)`（见上面 SessionQueryFace：
+* 一次交回 `events` 与 `inheritedEventCount`）。三条降级路径一律 `undefined`（调用方直接
+* 返回，**游标不推进**、不误报）：① `sessionQuery` 未装配（`Context["get"]` 的官方语义即
+* "or `undefined` when not (yet) provided"，installed cordis/lib/types/reflect.d.ts:12）；
+* ② `observeSession` 抛错/拒绝（会话已卸载、存储读不出）；③ 交回的 events 不是数组
+* （契约外交付，由 `isArrayDelivery` 那道**布尔**判据挡——不用 `Array.isArray` 作守卫收窄，
+* 它会把官方 `readonly SessionEvent[]` 塌成 `any[]`，类型面当场作废并把 any 传进下游记账）。
+* 窗口仍由**本地按 from 切片**：观察面给的是自日志开头的连续切片（`seq = log.length`
+* 连续性契约，installed dsh-session/lib/index.js:1285 的注记），而 `from` 是本包游标算出的
+* 裸 number——这样连 `SessionLogOffset` 的品牌都不必造（官方只要 `SessionId`，那一位从
+* `Session.id` 上拿回来就是品牌的）。
+*/
+async function resolveEventWindow(query, sessionId, lastSeq) {
+	let window;
+	if (query !== void 0) try {
+		const observation = await query.observeSession(sessionId);
+		const forkCut = observation.inheritedEventCount ?? 0;
+		const from = Math.max(forkCut, lastSeq.get(sessionId) ?? forkCut);
+		if (isArrayDelivery(observation.events)) window = {
+			from,
+			events: observation.events.slice(from)
+		};
+	} catch {
+		window = void 0;
+	}
+	return window;
+}
+/** 按有无 callId 分流：无 callId 直记（异常/旧形状/测试 mock 保守直记防漏），有则按 callId 关联。 */
+function storeEdit(callId, record, pending, noCallId) {
+	if (callId === void 0) noCallId.push(record);
+	else pending.set(callId, record);
+}
+/**
+* 单扫描事件流 → 编辑记账三表：callId→编辑（成功关联）、无 callId 直记表、失败 callId 集。
+* 只记成功编辑：被 danger-guard 拒绝或执行失败的 tool/result 标记失败 callId，跳过。
+* 记账骨架复用 shared scanToolEvents（事件解析/view 判定/坏参标记），本函数只做
+* 领域过滤（编辑工具集、路径记账语义）——与 danger-guard 不再各有 JSON.parse/view 双实现。
+*
+* 语义对照（与原本地实现等价）：
+*   - 坏参数（JSON 非法/非对象）→ 跳过记账（原 EDIT_SKIP）；
+*   - str_replace_editor view（只读）→ 跳过（原 EDIT_SKIP）；
+*   - 其余编辑调用按 callId 关联，tool/result isError 回填 failed。
+*/
+function collectEdits(events) {
+	const pending = /* @__PURE__ */ new Map();
+	const noCallId = [];
+	const failed = /* @__PURE__ */ new Set();
+	const { calls, results } = scanToolEvents(events);
+	for (const call of calls) if (call.name !== void 0 && isEditTool(call.name) && !call.badArguments) {
+		const target = editPathOf(call);
+		if (target.kind === "write") storeEdit(call.callId, {
+			name: call.name,
+			path: target.path
+		}, pending, noCallId);
+	}
+	for (const result of results) if (result.isError && result.callId !== void 0) failed.add(result.callId);
+	return {
+		pending,
+		noCallId,
+		failed
+	};
+}
+/** 单文件向上找最近的清单根；hitDepthLimit 标记是否因超深而无根（供可观测 warn）。
+*  maxDepth 来自 Config 的 maxRootDepth（W4 非 volatile 部署值）。 */
+function findManifestRoot(file, maxDepth) {
+	let dir = path.dirname(file);
+	let found;
+	let hitDepthLimit = false;
+	for (let depth = 0; depth < maxDepth; depth += 1) {
+		for (const manifest of MANIFESTS) if (existsSync(`${dir}/${manifest}`)) {
+			found = dir;
+			break;
+		}
+		if (found !== void 0) break;
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+		if (depth === maxDepth - 1) hitDepthLimit = true;
+	}
+	return {
+		root: found,
+		hitDepthLimit
+	};
+}
+/**
+* 命中最近清单后继续向上探测 pnpm-workspace.yaml —— workspace 根优先。
+* monorepo 子包（admin/src/x.ts）编辑应跑工作区全套 `pnpm check`，而非退化为子包 `tsc`。
+*/
+function workspaceRootUpgrade(root, maxDepth) {
+	let up = path.dirname(root);
+	for (let depth = 0; depth < maxDepth; depth += 1) {
+		if (existsSync(`${up}/pnpm-workspace.yaml`)) return up;
+		const parent = path.dirname(up);
+		if (parent === up) break;
+		up = parent;
+	}
+	return root;
+}
+/**
+* 探测一个根的真实盘上事实 → gate-detect 的入参形状（ProjectRoot）。
+*
+* - 清单名：MANIFESTS 里实际存在的项；
+* - tsconfig.json 不作为"根标记"（不进 MANIFESTS，避免改动根向上探测的语义），
+*   但要进清单集合——gate-detect 用它区分"真 TS 项目"与"只有 package.json 的空壳"；
+* - scripts：根 package.json 已声明的脚本名清单，交给 gate-detect 判定 pnpm check
+*   是否可用。**这里只做如实登记，不做取舍**（探测策略集中在纯函数里）。
+*/
+function probeProjectRoot(root) {
+	const manifests = MANIFESTS.filter((manifest) => existsSync(`${root}/${manifest}`));
+	if (existsSync(`${root}/tsconfig.json`)) manifests.push("tsconfig.json");
+	const scripts = manifests.includes("package.json") ? declaredScriptsOf(root) : void 0;
+	return scripts === void 0 ? {
+		root,
+		files: manifests
+	} : {
+		root,
+		files: manifests,
+		scripts
+	};
+}
+/** 注入载荷组装（id 唯一，同一毫秒多次注入也不碰撞）。 */
+const injectMessage = (text) => ({
+	id: `quality-gate-${randomUUID()}`,
+	role: "user",
+	content: [{
+		type: "text",
+		text
+	}],
+	source: { kind: GATE_SOURCE_KIND }
+});
+/**
+* 总线上报（自进化闭环）：门禁失败是事实，无论注入与否都要沉淀
+* ——修复环里同一门禁反复失败会形成 violation 序列，度量"提醒有没有用"。
+* 但"没跑成"以 gate-not-run 单独上报：环境/策略问题不得被学成代码教训（审计 HIGH 项
+* 的第二半——假的失败指令曾经既进注入又进记忆/lesson-loop）。
+* report 自身容错（同步抛错与异步拒绝经 settleLessonCall 落进同一条 warn）；
+* 总线缺失（未装 lesson-loop）时 get 返回 undefined 直接跳过。
+*/
+function reportProblemToBus(get, attribution, gate, problem, log) {
+	settleLessonCall(() => get("lessonLoop")?.report({
+		source: "quality-gate",
+		category: problem.kind === GATE_KIND_CODE_FAILURE ? "gate-failure" : "gate-not-run",
+		cwd: attribution.cwd,
+		sessionId: attribution.sessionId,
+		turn: attribution.turn,
+		signature: gate.command.join(" "),
+		detail: problem.text,
+		evidence: {
+			root: gate.root,
+			command: gate.command,
+			kind: problem.kind
+		}
+	}), (reason) => {
+		log.warn(`[quality-gate] lessonLoop report failed: ${messageOf(reason)}`);
+	});
+}
+/**
+* 设置 + dsh 凭据通道 → 一次投递目标；任一环节缺失只返回降级原因，**不抛**。
+*
+* 为什么不抛：记忆反馈是尽力而为的补强。别人机器上没有那台网关、没配凭据、甚至没装
+* 凭据服务都是**常态**，抛错会把一次正常的门禁失败升级成回合错误（且缺配置本就是
+* 用户要看见的信息，不是异常）。
+*
+* 密钥改走 ctx.credentials 后不再有 gateway.key 文件路径拼接：网关地址与令牌都是
+* "某台机器上的事实"，只能由使用者显式配置（设置项 + 凭据），不能被插件替所有人认定。
+*/
+async function resolveFeedbackTarget(cfg, credentials) {
+	const url = resolveGatewayUrl(cfg.memoryGatewayUrl);
+	if (url === "") return {
+		ok: false,
+		reason: "memoryGatewayUrl 未配置（留空 = 不启用记忆反馈）"
+	};
+	if (!isCredentialRefName(cfg.memoryGatewayKeyRef)) return {
+		ok: false,
+		reason: `memoryGatewayKeyRef "${cfg.memoryGatewayKeyRef}" 不是合法凭据引用名`
+	};
+	if (credentials === void 0) return {
+		ok: false,
+		reason: "credentials 服务未注册，网关密钥无从解析"
+	};
+	const hit = await credentials.resolve(credentialRef(cfg.memoryGatewayKeyRef));
+	if (hit === void 0) return {
+		ok: false,
+		reason: `凭据 ${cfg.memoryGatewayKeyRef} 未配置（值不落在设置里）`
+	};
+	return {
+		ok: true,
+		target: {
+			url,
+			key: hit.value
+		}
+	};
+}
+/**
+* 记忆反馈的降级说明只说一次：默认关闭之后仍把它打开的人，多半正是"少配了一项"的状态
+* （地址填了、凭据没配）。每个失败回合重复刷屏只会淹掉门禁日志。
+*/
+function warnMemorySkip(notice, reason) {
+	if (notice.warned) return;
+	notice.warned = true;
+	notice.log.warn(`[quality-gate] memory feedback skipped: ${reason}`);
+}
+/** 尽力而为的记忆反馈（内部消化错误，绝不阻塞门禁主流程）。 */
+async function pushFeedbackToMemory(get, notice, cfg, messages, input) {
+	try {
+		const resolution = await resolveFeedbackTarget(cfg, get("credentials"));
+		if (!resolution.ok) {
+			warnMemorySkip(notice, resolution.reason);
+			return;
+		}
+		await pushGateFeedback(input, resolution.target, messages);
+	} catch (error) {
+		notice.log.warn(`[quality-gate] memory feedback skipped: ${messageOf(error)}`);
+	}
+}
+/** 一次读全的解析后设置快照（旧 scope.get() 的等价物）：门禁按回合现读，纯值往下传，
+*  不必让每个消费方都持有引用。官方同款读法见 harness
+*  packages/llm/llm-deepseek/src/config.ts 的 `plainOptions(config)`。 */
+function settingsOf(config) {
+	return {
+		enabled: config.enabled.get(),
+		maxInjectsPerTurn: config.maxInjectsPerTurn.get(),
+		gateBudgetMs: config.gateBudgetMs.get(),
+		memoryFeedback: config.memoryFeedback.get(),
+		memoryGatewayUrl: config.memoryGatewayUrl.get(),
+		memoryGatewayKeyRef: config.memoryGatewayKeyRef.get()
+	};
+}
+/**
+* ctx 的本包服务面守卫（替代 `ctx as unknown as HostCtx` 断言：严格档下豁免注释
+* 不是合法手段）。cordis 的 ctx 是运行期代理，成员是否齐备只能按实际调用面核验。
+* 核验的是 **0.1.7 的实际面**：`settings.configure`（页面策略）+ `settings.describe`
+* （跨命名空间读）+ `inject` + `fiber` + `get`/`on`/`effect`。
+* ⚠ 不能再探 `settings.register`：0.1.7 已把它连同 get/installSection 一起移除，
+* 拿它当硬前置会让**每一条真宿主**都判成"服务面不齐"，`gate not armed` 于是成为
+* 唯一可能的失败模式（本包设置面失效就是这么静默掉下去的）。
+* 缺任一项一律 fail-closed：不注册监听、不写游标，只记一条 error，避免带着半截服务面
+* 在首个回合才崩（且崩溃会被折叠成 turn kind:error 直接甩给用户）。
+*/
+function isGateHost(value) {
+	if (!isRecord(value)) return false;
+	const { effect, fiber, get, inject, on, settings } = value;
+	return typeof get === "function" && typeof on === "function" && typeof effect === "function" && typeof inject === "function" && isRecord(fiber) && typeof fieldOf(settings, "describe") === "function" && typeof fieldOf(settings, "configure") === "function";
+}
+/**
+* 从编辑文件路径向上找最近的清单根（层数上限 = Config 的 maxRootDepth，W4 非 volatile
+* 部署值），每个根探一次真实盘上事实（清单名 + 已声明脚本）。找不到清单根的文件跳过
+* （无门禁面）。
+*/
+function projectRootsOf(files, maxDepth, log) {
+	const roots = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const hit = findManifestRoot(file, maxDepth);
+		const useRoot = hit.root;
+		if (useRoot === void 0) {
+			if (hit.hitDepthLimit) log.warn(`[quality-gate] no manifest within ${maxDepth} levels of ${file}; gate skipped for it`);
+		} else {
+			const upgraded = workspaceRootUpgrade(useRoot, maxDepth);
+			if (!roots.has(upgraded)) roots.set(upgraded, probeProjectRoot(upgraded));
+		}
+	}
+	return [...roots.values()];
+}
+/**
+* 执行一个门禁：只有 exitCode 0 才是 pass。
+* 超时/取消/信号/策略拒绝/工具装不上都走 classifyRun 的显式三态；
+* **catch 不再报通过**（审计 MEDIUM 项：workdir 不存在、spawn 失败、
+* SandboxUnavailableError 都曾落进 catch 被当 PASS）。
+*/
+async function runGate(messages, shell, gate, budgetMs, context) {
+	const { policy, signal, stdoutMaxBytes, log } = context;
+	let outcome;
+	try {
+		const spec = shell.resolve({
+			command: gate.command.join(" "),
+			workdir: gate.root,
+			stdoutMaxBytes,
+			timeoutMs: budgetMs,
+			signal,
+			...policy === void 0 ? {} : { sandboxPolicy: policy }
+		});
+		outcome = classifyRun(messages, gate, budgetMs, await (await shell.execute(spec)).result(), log);
+	} catch (error) {
+		log.error(`[quality-gate] gate did not run: ${gate.command.join(" ")} @ ${gate.root} — ${messageOf(error)}`);
+		const cause = messageOf(error);
+		outcome = isSandboxUnavailable(error) ? {
+			kind: "not-run",
+			text: renderTemplate(messages.sandboxUnavailable, { message: cause })
+		} : {
+			kind: "not-run",
+			text: renderTemplate(messages.gateStartFailed, { message: cause })
+		};
+	}
+	return outcome;
+}
+/**
+* 软依赖 shell 的唯一入口——用 ctx.get（可选服务官方读法，未注册返回 undefined）。
+*
+* **不可写成 `svc.shell`**：cordis ctx 的 Proxy get 陷阱对未列入 `inject` 的属性
+* 直接抛 `cannot get property "shell" without inject`（见 cordis reflect.ts 的
+* `ReflectService.handler.get`），于是下面的 `=== undefined` 判定永远走不到，
+* C9 静默放行分支形同虚设，且每回合结束都冒一个 turn 错误卡。
+* shell 服务由 host 组合（@deepseek-ai/dsh-shell 的 Service 构造即注册），
+* 正常环境下 get 命中；异常环境才落 C9。
+*
+* **也不加 `?? svc.shell` 兜底**：shell 真缺失时右值会重新触发同一个抛错，
+* 兜底反而把 C9 再打断。mock 需实现 get() 才有意义。
+*/
+function getShell(rt) {
+	return rt.svc.get("shell");
+}
+/** 取本会话的解析后沙箱策略（审计 HIGH 项）。`session` 交官方 `Session` 类本身：
+*  官方 `SandboxPolicyRequest.session` 就是这个类（@deepseek-ai/dsh-sandbox-policy/lib/
+*  types/index.d.ts:52），而 `Session` 带私有字段、按名义比 —— 本包那个只服务退役中同步
+*  读面的 SessionRef 视图交不进去，编译器原话：`Type 'SessionRef' is missing the following
+*  properties from type 'Session': log, surfaceManager, surface, firstLiveSeq, and 18 more`。
+*  这里要的是 turn-stopping 载荷里那一个真实 Session，故用官方类型而不是视图。 */
+function resolvePolicy(rt, messages, session) {
+	const policy = rt.svc.get("sandboxPolicy");
+	let result;
+	if (policy === void 0) result = {
+		kind: "ok",
+		policy: void 0
+	};
+	else try {
+		result = {
+			kind: "ok",
+			policy: policy.resolve({ session })
+		};
+	} catch (error) {
+		result = {
+			kind: "unavailable",
+			reason: renderTemplate(messages.policyUnresolvable, { message: messageOf(error) })
+		};
+	}
+	return result;
+}
+/**
+* 会话自己的累加器（缺失即建；建完按会话预算淘汰最旧的其他会话）。
+* 条目**不随 drain 释放**：保留下来才让"本会话自己"这条账连续（下一回合复用同一实例，
+* 容量淘汰计数也不会串到别的会话上），总大小由 SESSION_BUDGET 收敛。
+*/
+function accumulatorOf(rt, sessionId) {
+	let acc = rt.accumulators.get(sessionId);
+	if (acc === void 0) {
+		acc = new EditAccumulator();
+		rt.accumulators.set(sessionId, acc);
+		pruneToSessionBudget(rt.accumulators, sessionId);
+	}
+	return acc;
+}
+/**
+* 从事件流读本回合**成功**编辑的文件（按官方观察面给的增量窗），记进本会话的账。
+* 低危修复（authoritative 记账）：被 danger-guard 拒绝或执行失败的编辑，其 tool/call
+* 仍在事件流里——旧实现照记，会对未真正改动的文件（若落在独立项目根）多跑一次门禁。
+* 改为：tool/call 建 callId→{name,path}，tool/result 的 isError 标记失败 callId，只记成功的。
+* turn-stopping 时本回合 call+result 同处一个增量窗，单次扫描即可关联；无 callId 的事件
+* （异常/旧形状/测试 mock）保守直记，避免漏门禁。
+* fork 前缀修复（源码核对 0.1.3 后落地）：子代理会话 fork 自父会话时，
+* 事件流含父事件前缀，游标从 0 首读会把父会话的历史编辑一并计入、多跑门禁。
+* Session.inheritedEventCount（0.1.2-rc.1 起公开只读）给出 fork 切点——首读下限
+* 取切点而非 0，父前缀天然跳过；缺属性退回 0（旧行为，保守不漏门禁）。
+*/
+async function readEditedFiles(rt, agent, acc) {
+	const { session } = agent;
+	const sessionId = session.id;
+	const window = await resolveEventWindow(rt.svc.get("sessionQuery"), sessionId, rt.lastSeqBySession);
+	if (window === void 0) return;
+	rt.lastSeqBySession.set(sessionId, window.from + window.events.length);
+	pruneToSessionBudget(rt.lastSeqBySession, sessionId);
+	const edits = collectEdits(window.events);
+	const { cwd } = session.header;
+	const note = (name, pathValue) => {
+		let resolvedPath = pathValue;
+		if (resolvedPath !== void 0 && cwd !== void 0 && !path.isAbsolute(resolvedPath)) resolvedPath = path.resolve(cwd, resolvedPath);
+		acc.note(name, resolvedPath);
+	};
+	for (const entry of edits.noCallId) note(entry.name, entry.path);
+	for (const [callId, entry] of edits.pending) if (!edits.failed.has(callId)) note(entry.name, entry.path);
+}
+/**
+* 处理一次门禁问题（代码失败或没跑成）：上报 + 二次校验 + 配额 + 注入；返回是否停止剩余门禁。
+* **同步**：整段体（bus 上报、二次校验、配额记账、followup 注入、日志）都就地完成，没有任何
+* 该等的 await——`memoryFeedback` 那笔是刻意 detached 的补强（在下面 `void` 掉：它失败不得
+* 回滚一次已成功的注入，更不能拖住回合），把它 await 进来会改变语义。留着 `async` 只是给
+* 调用点多塞一个微任务，故按实际形状收成同步（eslint/typescript require-await 同判）。
+*/
+function handleGateFailure(scope, target, problem) {
+	const { rt, agent, cfg, messages, sessionId, turn, cwd } = scope;
+	const { log, injectState, memoryNotice } = rt;
+	const maxInjects = cfg.maxInjectsPerTurn;
+	const isCodeFailure = problem.kind === GATE_KIND_CODE_FAILURE;
+	reportProblemToBus(rt.svc.get, {
+		sessionId,
+		turn,
+		cwd
+	}, target, problem, log);
+	const check = preInjectCheck(agent, scope.signal);
+	if (!check.ok) {
+		log.warn(`[quality-gate] ${sessionId}: injection skipped (${check.reason}) at turn ${turn}`);
+		return true;
+	}
+	const st = injectState.get(sessionId) ?? {
+		count: 0,
+		gaveUp: false
+	};
+	if (st.count >= maxInjects) {
+		if (!st.gaveUp) {
+			st.gaveUp = true;
+			injectState.set(sessionId, st);
+			try {
+				agent.followup(injectMessage(giveUpText(messages, target, st.count)));
+				log.warn(`[quality-gate] ${sessionId}: giving up after ${st.count} repair attempts (gate still failing)`);
+			} catch (error) {
+				log.error(`[quality-gate] ${sessionId}: give-up followup failed: ${messageOf(error)}`);
+			}
+		}
+		return true;
+	}
+	st.count += 1;
+	injectState.set(sessionId, st);
+	pruneToSessionBudget(injectState, sessionId);
+	try {
+		agent.followup(injectMessage(isCodeFailure ? gateText(messages, target, problem.text) : notRunText(messages, target, problem.text)));
+		log.info(`[quality-gate] ${sessionId}: ${isCodeFailure ? "gate failure" : "gate not-run"} injected at turn ${turn} (attempt ${st.count}/${maxInjects})`);
+		if (isCodeFailure && cfg.memoryFeedback) pushFeedbackToMemory(rt.svc.get, memoryNotice, cfg, messages, {
+			cwd,
+			command: target.command,
+			root: target.root,
+			failure: problem.text
+		});
+		return true;
+	} catch (error) {
+		st.count -= 1;
+		injectState.set(sessionId, st);
+		log.error(`[quality-gate] ${sessionId}: followup failed: ${messageOf(error)}`);
+		return false;
+	}
+}
+/** 卸载收口的读法：两次判读之间隔着 `await runGate(...)`，那期间 disposer 的 abort() 是真会
+*  发生的（W4 收口由测试钉住）；直接读 `gateAbort.signal.aborted` 会被控制流分析钉在前一次
+*  判读的 false 上（属性窄不跨 await 复位），后一处守卫就被判成恒假。经函数取值 ⇒ 每读都按
+*  声明的 boolean 算，守卫才是必要的。 */
+function gateAborted(rt) {
+	return rt.gateAbort.signal.aborted;
+}
+/**
+* 顺序执行门禁（决策是顺序依赖的：预算封顶 + 每次只注入一个失败），
+* 用尾递归推进代替 for+await（规避 no-await-in-loop，语义不变）。
+*/
+async function processGate(state, left) {
+	const { scope, shell, resolved, signal, budget, perGate, started, batch } = state;
+	const { rt } = scope;
+	const [gate] = left;
+	if (gate === void 0) return;
+	if (gateAborted(rt)) return;
+	const remaining = budget - (Date.now() - started);
+	if (remaining < MIN_USEFUL_GATE_MS) {
+		batch.blocked = true;
+		handleGateFailure(scope, gate, {
+			kind: "not-run",
+			text: skippedText(scope.messages, left)
+		});
+		return;
+	}
+	const outcome = resolved.kind === "unavailable" ? {
+		kind: "not-run",
+		text: resolved.reason
+	} : await runGate(scope.messages, shell, gate, Math.min(perGate, remaining), {
+		policy: resolved.policy,
+		signal,
+		stdoutMaxBytes: rt.stdoutMaxBytes,
+		log: rt.log
+	});
+	if (gateAborted(rt)) return;
+	if (outcome.kind === "pass") {
+		await processGate(state, left.slice(1));
+		return;
+	}
+	batch.blocked = true;
+	if (!handleGateFailure(scope, gate, outcome)) await processGate(state, left.slice(1));
+}
+/**
+* 一趟门禁批次：C4 按总预算封顶（perGate 保底 10s 会超支）——跟踪已花时间，每门
+* min(perGate, remaining)。尾段不足最小可用预算（真实 tsc/pnpm 冷启动也要数秒，几百 ms
+* 必超时 → 假"超时失败"注入）时**注入未执行说明**——旧实现只 console.warn，那等于静默
+* 通过（审计 MEDIUM 项）。
+*
+* W4 防御收口：①整段顶层 try/catch——批次自身故障只记一条 error，绝不产生
+* unhandledRejection；②批次 promise 由调用方登记进在飞账本，disposer abort 后 await 收敛
+* （defensive-patterns.md:19-23：dispose 必须终止并等待在飞工作）。
+*/
+async function runGateBatch(input) {
+	const { scope } = input;
+	const { rt, sessionId } = scope;
+	try {
+		const perGate = Math.max(1e4, Math.floor(input.budget / input.gates.length));
+		const started = Date.now();
+		/** 是否有门禁未给出"通过"结论（code-failure 与 not-run 都算；只有全 pass 才重置配额）。
+		*  放进可变持有对象而不是 `let`：赋值全在 `processGate` 里，控制流分析看不见那两次
+		*  写，批次结束后的读点会被钉在初值 false 上、`!batch.blocked` 就被判成恒真——而「有门没给出
+		*  通过结论」是真会发生的（配额重置与否由它决定）。属性读保留声明的 boolean，守卫才是真的。 */
+		const batch = { blocked: false };
+		await processGate({
+			...input,
+			perGate,
+			started,
+			batch
+		}, input.gates);
+		if (!batch.blocked) rt.injectState.delete(sessionId);
+	} catch (error) {
+		rt.log.error(`[quality-gate] ${sessionId}: gate batch failed: ${messageOf(error)}`);
+	}
+}
+/**
+* 一次回合收口（原 turn-stopping 监听器里的匿名 `run`）：守卫 → 记账 → 探测门禁 →
+* detached 跑批次。整段仍是同一条同步/异步切分——门禁执行 detached（不拖回合收尾），
+* 事件读那一次 await 留在回合内（`@mode serial` 派发下与原形状等价）。
+*/
+async function handleTurnGate(rt, payload) {
+	const { agent } = payload;
+	if (agent === void 0) return;
+	if (rt.disposed) return;
+	const cfg = settingsOf(rt.config);
+	if (!cfg.enabled) return;
+	if (!isRootSession(agent)) return;
+	const messages = rt.messages();
+	const { session } = agent;
+	const { id: sessionId } = session;
+	/** 会话 cwd（turn-stopping 载荷 header.cwd）：相对路径解析基准 + 记忆/总线归因。 */
+	const { cwd } = session.header;
+	if (inboxHasPending(agent.inbox)) {
+		pruneToSessionBudget(rt.injectState, sessionId);
+		return;
+	}
+	if (typeof payload.turn !== "number") return;
+	const { turn } = payload;
+	const shell = getShell(rt);
+	if (shell === void 0) {
+		if (!rt.shellWarned) {
+			rt.shellWarned = true;
+			rt.log.warn("[quality-gate] shell service unavailable; gates skipped (pass-through)");
+		}
+		return;
+	}
+	const acc = accumulatorOf(rt, sessionId);
+	await readEditedFiles(rt, agent, acc);
+	const dropped = acc.droppedCount();
+	const files = acc.drain();
+	if (dropped > 0) rt.log.warn(`[quality-gate] ${sessionId}: ${dropped} edited file(s) evicted from accumulator cap; gate may miss their roots`);
+	if (files.length === 0) return;
+	const { gateBudgetMs: budget } = cfg;
+	const gates = detectGate(projectRootsOf(files, rt.maxRootDepth, rt.log));
+	if (gates.length === 0) return;
+	const resolved = resolvePolicy(rt, messages, session);
+	const gateSignal = payload.signal === void 0 ? rt.gateAbort.signal : AbortSignal.any([payload.signal, rt.gateAbort.signal]);
+	const flight = runGateBatch({
+		scope: {
+			rt,
+			agent,
+			cfg,
+			messages,
+			sessionId,
+			turn,
+			cwd,
+			signal: payload.signal
+		},
+		gates,
+		shell,
+		resolved,
+		signal: gateSignal,
+		budget
+	});
+	rt.inFlightGates.add(flight);
+	(async () => {
+		await flight;
+		rt.inFlightGates.delete(flight);
+	})();
+}
+function apply(ctx, config) {
+	if (!isGateHost(ctx)) {
+		console.error("[quality-gate] ctx is missing the settings.describe/configure + inject/fiber surface; gate not armed");
+		return;
+	}
+	const svc = ctx;
+	const log = svc.logger?.("quality-gate") ?? console;
+	const { maxRootDepth, gateStdoutMaxBytes: stdoutMaxBytes } = config;
+	svc.inject(["settings"], (child) => {
+		child.effect(() => child.settings.configure({ auto: false }, svc.fiber));
+	});
+	const localeMessages = () => messagesFor(MESSAGES, resolveLocalePreference(svc.settings.describe().find((row) => row.ns === LOCALE_SETTINGS_NAMESPACE)?.value));
+	const rt = {
+		svc,
+		config,
+		log,
+		maxRootDepth,
+		stdoutMaxBytes,
+		messages: localeMessages,
+		accumulators: /* @__PURE__ */ new Map(),
+		injectState: /* @__PURE__ */ new Map(),
+		lastSeqBySession: /* @__PURE__ */ new Map(),
+		memoryNotice: {
+			warned: false,
+			log
+		},
+		gateAbort: new AbortController(),
+		inFlightGates: /* @__PURE__ */ new Set(),
+		shellWarned: false,
+		disposed: false
+	};
+	svc.on("agent/turn-stopping", async (payload) => {
+		try {
+			await handleTurnGate(rt, payload);
+		} catch (error) {
+			rt.log.error(`[quality-gate] turn-stopping handler failed (gate skipped): ${messageOf(error)}`);
+		}
+	});
+	svc.effect(() => () => {
+		rt.disposed = true;
+		rt.gateAbort.abort();
+		rt.injectState.clear();
+		rt.lastSeqBySession.clear();
+		rt.accumulators.clear();
+		return Promise.allSettled(rt.inFlightGates);
+	});
+}
+var host_default = {
+	inject: ["settings"],
+	Config,
+	apply
+};
+//#endregion
+export { Config, apply, host_default as default };