@sema-agent/server 7.63.0 → 7.64.0

package/dist/leader/fanout.d.ts

@@ -27,7 +27,7 @@
  * MVP scope: the COMPOSITION mechanics, unit-tested with a mock runner. Real E2B workers + branch/baseSha from
  * a worker's actual git state are wired at M4/M5 (joint dogfood).
  */
-import type { TaskSpec, TaskResult, TaskStream, RepairTerminal } from "@sema-agent/core";
+import { type TaskSpec, type TaskResult, type TaskStream, type RepairTerminal, type CheckpointGate } from "@sema-agent/core";
 /** What the Coordinator gets back per worker (council#6 — merge(b) routes on this). */
 export interface WorkerReport {
     workerId: string;
@@ -48,10 +48,11 @@ export interface WorkerReport {
     /** [ref] Slice 6: the terminal checkpoint gate when a worker is still SUSPENDED (the leader auto-resumed
      *  it up to its bound but it didn't fully complete — e.g. the overall deadline hit or the slice cap). Present
      *  ⇒ resumable: the operator/leader can escalate (more budget) or accept the belt-diff partial progress. */
-    checkpointGate?: TaskResult["checkpointGate"];
-    /** [ref] Slice 6: the worker's terminal `TaskResult.errorCode` (e.g. `limits.max_cost_exceeded` on an
-     *  exhausted resume, `limits.max_turns_exceeded` — core 5.8.0 码名轴) — surfaced for /v1/leader observability. */
-    errorCode?: TaskResult["errorCode"];
+    checkpointGate?: CheckpointGate;
+    /** [ref] Slice 6: the worker's terminal failure code (e.g. `limits.max_cost_exceeded` on an
+     *  exhausted resume, `limits.max_turns_exceeded` — core 5.8.0 码名轴) — surfaced for /v1/leader observability.
+     *  S-136:源从 `TaskResult.errorCode` 换成因由 `failed` 臂的 `code`(本报告面的键名与形不变)。 */
+    errorCode?: string;
     /** LEADER-REPAIRLOOP-INTEGRATION §10.6 (THE push chokepoint): the `runRepairLoop` terminal a single-agent
      *  worker resolved to, when the repair loop ran on this worker (LEADER_REPAIR_LOOP on). It MUST ride on the
      *  report because a SAFE-tier `candidate_only` maps to core verdict "PASS" → this report's `status` collapses
@@ -105,24 +106,6 @@ export interface FanOutResult {
     /** True if the overall deadline fired and cancelAll ran. */
     cancelled: boolean;
 }
-/**
- * 「这条 worker 的 TaskResult 停在门上(durable park)了吗」——`TaskStatus` 的穷举判据。
- *
- * 🔴 park 是**两个词**(扫描P2,status/kind 同名词混淆病族):`suspended`(工具审批 / human /
- * resource_limit 门)与 `needs_review`(`plan_review` 与 dry-run 拦截门)。真源 = core
- * `agents/suspend-guard.js` 的 `isDurablePause`(逐字 `status === "suspended" || status === "needs_review"`),
- * `mapNestedSuspend` / `verify.js` 的 `unverifiedReason` 两处都按这张表分词。
- *
- * 只认 `suspended` 的后果不是「少一个标签」:一条 plan_review 停下的 worker 会被报成 `failed` ⇒
- * fanOut 的 C4 抢占({@link FanOutOptions.cancelOnSuspend})不触发(其余 worker 继续烧钱)、leader 的
- * replan「suspended 波」看不见它、`suspendedSessions` 的豁免名单漏掉它 ⇒ 它那张还能被决议的 checkpoint
- * 与暂停中的环境会被当失败清掉。带验证器的那条腿早已改用「还带着 checkpointToken 就是 park」的判据
- * (leader.ts round-3 review BLOCKER),这里是它当时漏掉的另外半场。
- *
- * `never` 收敛 = core `TaskStatus` 增删成员的**编译期**执行点(同 `store-contracts.ts` 两条判据的姿势);
- * 运行时未知词保守判**非 park**(与既有 `else → failed` 同行为,不静默扩大 park 面)。
- */
-export declare function isDurablePauseStatus(s: TaskResult["status"]): boolean;
 /**
  * Fan out `subtasks` in parallel. Never throws — every worker resolves to a WorkerReport (failures captured).
  * The caller (Coordinator) merges only `status==="completed"` reports.

package/dist/leader/fanout.js

@@ -1,4 +1,6 @@
+import { terminalProjection } from "@sema-agent/core";
 import { redactErrorMessage, redactWorkerReportError } from "../observability/run-terminal-log.js";
+import { pausedCauseOf } from "../terminal.js";
 class Semaphore {
     max;
     active = 0;
@@ -19,24 +21,10 @@ class Semaphore {
         }
     }
 }
-export function isDurablePauseStatus(s) {
-    switch (s) {
-        case "suspended":
-        case "needs_review":
-            return true;
-        case "completed":
-        case "failed":
-        case "blocked":
-            return false;
-        default: {
-            const unhandled = s;
-            void unhandled;
-            return false;
-        }
-    }
-}
-function mapStatus(s) {
-    return s === "completed" ? "completed" : isDurablePauseStatus(s) ? "suspended" : "failed";
+function mapStatus(terminal) {
+    if (terminal.kind === "completed")
+        return "completed";
+    return pausedCauseOf(terminal) !== undefined ? "suspended" : "failed";
 }
 export async function fanOut(subtasks, opts) {
     const sharedAC = new AbortController();
@@ -80,7 +68,8 @@ export async function fanOut(subtasks, opts) {
             let report;
             try {
                 const result = await stream.result();
-                report = { ...base, status: mapStatus(result.status), stats: result.stats, ...(result.errorMessage ? { error: redactErrorMessage(result.errorMessage) ?? "" } : {}) };
+                const plane = terminalProjection(result.terminal);
+                report = { ...base, status: mapStatus(result.terminal), stats: result.stats, ...(plane.errorMessage ? { error: redactErrorMessage(plane.errorMessage) ?? "" } : {}) };
             }
             catch (e) {
                 report = { ...base, status: cancelled ? "timeout" : "failed", error: redactErrorMessage(e instanceof Error ? e.message : String(e)) ?? "" };

package/dist/leader/leader.d.ts

@@ -15,18 +15,21 @@
 import { type RunnerLike, type WorkerReport } from "./fanout.js";
 import { type ExecStreamLike } from "./diffout.js";
 import { type MergeDeps, type MergeResult } from "./merge.js";
-import { type TaskSpec, type VerifyConfig, type CheckpointToken, type ToolSpec, type RepairTerminal, type OracleTier, type RepairResult } from "@sema-agent/core";
+import { type TaskSpec, type VerifyConfig, type CheckpointToken, type TerminalCause, type ToolSpec, type RepairTerminal, type OracleTier, type RepairResult } from "@sema-agent/core";
 /** [ref] Slice 6: drive a worker's resource-suspend auto-resume to a terminal (or bound) state. Exported
- *  for unit tests. Loops `resume(token, slice)` WHILE the result carries a `resource_limit` checkpoint gate —
- *  NOT by status (the verify wrapper may surface a suspend as failed-with-token). Exits on: a terminal result
- *  (completed/failed → no gate), an exhausted budget (core fails the resume fast → no token/gate), a
- *  human-approval gate (kind ≠ "resource_limit" — never auto-resumed), `signal.aborted`, or `maxSlices` (a
- *  belt; core's ledger fail-fast + per-task suspend-loop cap are the primary bounds). Returns the final result. */
+ *  for unit tests. Loops `resume(token, slice)` WHILE the result's terminal cause is a park on a
+ *  `resource_limit` gate. Exits on: a terminal cause that is not a park, a park on any OTHER gate
+ *  (a human approval / a review — never auto-resumed), an exhausted budget (core fails the resume fast, so
+ *  the cause is `failed` with no nested park), `signal.aborted`, or `maxSlices` (a belt; core's ledger
+ *  fail-fast + per-task suspend-loop cap are the primary bounds). Returns the final result.
+ *
+ *  🔴 S-136(core 7.6.0 D-8):判据从「两个平面键合读」(`checkpointToken` 在场 ∧ `checkpointGate.kind`)
+ *  换成**一条因由**({@link pausedCauseOf}) —— 这条循环从一开始就刻意**不按 status 判**(顶注原话:
+ *  「the verify wrapper may surface a suspend as failed-with-token」),因为嵌套边界会把 park 报成 failed;
+ *  现在那件事是形状:两条路径同一个读法,而 token 与 gate 在同一个 `PausedCause` 上,不可能只有一半。
+ */
 export declare function autoResumeOnResource<T extends {
-    checkpointToken?: CheckpointToken;
-    checkpointGate?: {
-        kind: string;
-    };
+    terminal: TerminalCause;
 }>(initial: T, signal: {
     readonly aborted: boolean;
 }, resume: (token: CheckpointToken, slice: number) => Promise<T>, maxSlices?: number): Promise<T>;

package/dist/leader/leader.js

@@ -1,13 +1,17 @@
-import { fanOut, isDurablePauseStatus } from "./fanout.js";
+import { fanOut } from "./fanout.js";
 import { redactErrorMessage, redactHead, redactPatchHead } from "../observability/run-terminal-log.js";
 import { pullDiff } from "./diffout.js";
 import { mergeBranches } from "./merge.js";
-import { Runner, runWithVerification, resumeWithVerification, delimitUntrusted } from "@sema-agent/core";
+import { Runner, runWithVerification, resumeWithVerification, delimitUntrusted, terminalProjection } from "@sema-agent/core";
+import { pausedCauseOf } from "../terminal.js";
 const MAX_RESUME_SLICES = 200;
 export async function autoResumeOnResource(initial, signal, resume, maxSlices = MAX_RESUME_SLICES) {
     let vr = initial;
-    for (let slice = 0; vr.checkpointToken !== undefined && vr.checkpointGate?.kind === "resource_limit" && !signal.aborted && slice < maxSlices; slice++) {
-        vr = await resume(vr.checkpointToken, slice + 1);
+    for (let slice = 0; slice < maxSlices && !signal.aborted; slice++) {
+        const paused = pausedCauseOf(vr.terminal);
+        if (paused === undefined || paused.gate.kind !== "resource_limit")
+            break;
+        vr = await resume(paused.token, slice + 1);
     }
     return vr;
 }
@@ -55,21 +59,23 @@ export async function runLeaderTask(task, durableBaseSha, deps) {
                             deps.logger?.info?.("worker_resource_resume", { workerId: w.workerId, slice });
                             return runner.resume(token, { gate: "resource_limit", decision: "continue" }, { ...w.spec, sessionId: w.sessionId, signal });
                         });
-                        if (r.status !== "completed") {
+                        const plane = terminalProjection(r.terminal);
+                        const paused = pausedCauseOf(r.terminal);
+                        if (r.terminal.kind !== "completed") {
                             deps.logger?.warn?.("worker_failed", {
-                                workerId: w.workerId, status: r.status, turns: r.stats?.turns ?? 0,
-                                ...(r.errorCode ? { errorCode: r.errorCode } : {}),
-                                ...(r.errorMessage ? { error: redactHead(r.errorMessage, 200) } : {}),
-                                ...(r.blockedReason ? { blockedReason: redactHead(r.blockedReason, 200) } : {}),
+                                workerId: w.workerId, status: plane.status, turns: r.stats?.turns ?? 0,
+                                ...(plane.errorCode ? { errorCode: plane.errorCode } : {}),
+                                ...(plane.errorMessage ? { error: redactHead(plane.errorMessage, 200) } : {}),
+                                ...(plane.blockedReason ? { blockedReason: redactHead(plane.blockedReason, 200) } : {}),
                             });
                         }
                         return {
                             ...base,
-                            status: r.status === "completed" ? "completed" : isDurablePauseStatus(r.status) ? "suspended" : "failed",
+                            status: r.terminal.kind === "completed" ? "completed" : paused !== undefined ? "suspended" : "failed",
                             stats: r.stats,
-                            ...(r.status === "completed" ? {} : { error: r.errorMessage ?? r.blockedReason ?? `worker ${r.status}` }),
-                            ...(r.checkpointGate ? { checkpointGate: r.checkpointGate } : {}),
-                            ...(r.errorCode ? { errorCode: r.errorCode } : {}),
+                            ...(r.terminal.kind === "completed" ? {} : { error: plane.errorMessage ?? plane.blockedReason ?? `worker ${plane.status}` }),
+                            ...(paused ? { checkpointGate: paused.gate } : {}),
+                            ...(plane.errorCode ? { errorCode: plane.errorCode } : {}),
                         };
                     },
                 });
@@ -86,16 +92,18 @@ export async function runLeaderTask(task, durableBaseSha, deps) {
                         deps.logger?.info?.("worker_resource_resume", { workerId: w.workerId, slice });
                         return resumeWithVerification(w.runner, token, { gate: "resource_limit", decision: "continue" }, { ...w.spec, sessionId: w.sessionId, signal }, w.spec.objective ?? "", cfg);
                     });
-                    deps.logger?.info?.("verify_outcome", { workerId: w.workerId, status: vr.status, verdict: vr.verification.verdict, rounds: vr.verification.rounds, finding: redactHead(vr.verification.findings[0] ?? "", 220) });
-                    const pass = vr.status === "completed" && vr.verification.verdict === "PASS";
-                    const stillSuspended = vr.checkpointToken !== undefined;
+                    const vrPlane = terminalProjection(vr.terminal);
+                    deps.logger?.info?.("verify_outcome", { workerId: w.workerId, status: vrPlane.status, verdict: vr.verification.verdict, rounds: vr.verification.rounds, finding: redactHead(vr.verification.findings[0] ?? "", 220) });
+                    const pass = vr.terminal.kind === "completed" && vr.verification.verdict === "PASS";
+                    const vrPaused = pausedCauseOf(vr.terminal);
+                    const stillSuspended = vrPaused !== undefined;
                     const reportStatus = pass ? "completed" : stillSuspended ? "suspended" : "failed";
                     if (reportStatus !== "completed") {
                         deps.logger?.warn?.("worker_failed", {
                             workerId: w.workerId, status: reportStatus, turns: vr.stats?.turns ?? 0, verdict: vr.verification.verdict,
-                            ...(vr.errorCode ? { errorCode: vr.errorCode } : {}),
-                            ...(vr.errorMessage ? { error: redactHead(vr.errorMessage, 200) } : {}),
-                            ...(vr.blockedReason ? { blockedReason: redactHead(vr.blockedReason, 200) } : {}),
+                            ...(vrPlane.errorCode ? { errorCode: vrPlane.errorCode } : {}),
+                            ...(vrPlane.errorMessage ? { error: redactHead(vrPlane.errorMessage, 200) } : {}),
+                            ...(vrPlane.blockedReason ? { blockedReason: redactHead(vrPlane.blockedReason, 200) } : {}),
                         });
                     }
                     return {
@@ -105,11 +113,11 @@ export async function runLeaderTask(task, durableBaseSha, deps) {
                             ? {}
                             : {
                                 error: vr.verification.verdict === "unverified"
-                                    ? (vr.errorMessage ?? vr.blockedReason ?? `worker ${vr.status}`)
+                                    ? (vrPlane.errorMessage ?? vrPlane.blockedReason ?? `worker ${vrPlane.status}`)
                                     : `verify ${vr.verification.verdict}: ${redactHead(vr.verification.findings[0] ?? "", 200)}`,
                             }),
-                        ...(vr.checkpointGate ? { checkpointGate: vr.checkpointGate } : {}),
-                        ...(vr.errorCode ? { errorCode: vr.errorCode } : {}),
+                        ...(vrPaused ? { checkpointGate: vrPaused.gate } : {}),
+                        ...(vrPlane.errorCode ? { errorCode: vrPlane.errorCode } : {}),
                     };
                 },
             });

package/dist/leader/repair-wire.d.ts

@@ -83,9 +83,12 @@ export interface RepairWireCfg {
         verifierModelId: string;
     };
     /** Per-attempt observability callback. */
+    /** S-136(core 7.6.0 D-8):键名随 core 从 `terminal` 改成 `repairTerminal` —— `terminal` 这个名字在
+     *  `TaskResult` 上已经归**运行终局因由**所有,修复循环的判词与它同名会是两个不同东西共用一个名字
+     *  (本仓 status/kind 同名词混淆病族)。 */
     onAttempt?: (info: {
         attempt: number;
-        terminal?: RepairTerminal;
+        repairTerminal?: RepairTerminal;
         oracleTier: OracleTier;
         passed: boolean;
         flaky: boolean;

package/dist/leader/repair-wire.js

@@ -1,5 +1,6 @@
 import { runRepairLoop, delimitUntrusted, } from "@sema-agent/core";
 import { mkRepairOracle } from "./repair-oracle.js";
+import { terminalProjection } from "@sema-agent/core";
 import { redactHead } from "../observability/run-terminal-log.js";
 function statusForTerminal(t) {
     return t === "fixed" || t === "candidate_only" ? "completed" : "failed";
@@ -40,7 +41,7 @@ async function runRepairLoopForLeaderInner(solo, implSpec, cfg) {
             ...(cfg.costCeilingMicroUsd !== undefined ? { costCeilingMicroUsd: cfg.costCeilingMicroUsd } : {}),
             ...(cfg.totalTimeoutMs !== undefined ? { totalTimeoutMs: cfg.totalTimeoutMs } : {}),
             ...(cfg.onAttempt
-                ? { onAttempt: (i) => cfg.onAttempt({ attempt: i.attempt, terminal: i.terminal, oracleTier: i.oracle.tier, passed: i.oracle.passed, flaky: i.oracle.flaky }) }
+                ? { onAttempt: (i) => cfg.onAttempt({ attempt: i.attempt, repairTerminal: i.repairTerminal, oracleTier: i.oracle.tier, passed: i.oracle.passed, flaky: i.oracle.flaky }) }
                 : {}),
             onWarn: (e) => cfg.log?.("repair_loop_warn", { warning: redactHead(e.message, 2000) }),
         });
@@ -50,13 +51,14 @@ async function runRepairLoopForLeaderInner(solo, implSpec, cfg) {
         cfg.log?.("repair_loop_threw", { error: safe });
         return { report: { ...base, status: "failed", error: safe }, result: undefined };
     }
-    const terminal = result.terminal;
+    const terminal = result.repairTerminal;
+    const plane = terminalProjection(result.terminal);
     const report = {
         ...base,
-        status: statusForTerminal(terminal),
-        repairTerminal: terminal,
+        status: terminal === undefined ? "failed" : statusForTerminal(terminal),
+        ...(terminal !== undefined ? { repairTerminal: terminal } : {}),
         ...(result.stats ? { stats: result.stats } : {}),
-        ...(result.errorMessage ? { error: result.errorMessage } : {}),
+        ...(plane.errorMessage ? { error: plane.errorMessage } : {}),
     };
     let candidatePatch;
     if (terminal !== "oracle.unprotected" && terminal !== "fixed") {

package/dist/leader/wire.js

@@ -1,3 +1,4 @@
+import { terminalProjection } from "@sema-agent/core";
 import { parseNumOrFail } from "../config.js";
 import { execFileSync } from "node:child_process";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
@@ -188,8 +189,8 @@ export function createLeaderRunner(cfg) {
                         limits: { maxCostUsd: repairBudgetUsd, maxWalltimeMs: Math.max(300_000, Math.floor(leaderTimeoutMs / 2)) },
                     })
                         .result();
-                    if (res.status !== "completed")
-                        throw new Error(`repair round ${round} did not complete (status=${res.status})`);
+                    if (res.terminal.kind !== "completed")
+                        throw new Error(`repair round ${round} did not complete (status=${terminalProjection(res.terminal).status})`);
                     return { costUsd: res.stats?.costMicroUsd !== undefined ? res.stats.costMicroUsd / 1e6 : undefined, note: res.result?.slice(0, 200) };
                 }
                 finally {
@@ -225,8 +226,8 @@ export function createLeaderRunner(cfg) {
                         limits: { maxCostUsd: repairBudgetUsd, maxWalltimeMs: Math.max(300_000, Math.floor(leaderTimeoutMs / 2)) },
                     })
                         .result();
-                    if (res.status !== "completed")
-                        throw new Error(`conflict-resolve round ${round} did not complete (status=${res.status})`);
+                    if (res.terminal.kind !== "completed")
+                        throw new Error(`conflict-resolve round ${round} did not complete (status=${terminalProjection(res.terminal).status})`);
                     return { costUsd: res.stats?.costMicroUsd !== undefined ? res.stats.costMicroUsd / 1e6 : undefined, note: res.result?.slice(0, 200) };
                 }
                 finally {

package/dist/main.js

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { Runner, createPermissionRuleStoreProvider, InMemoryToolResultStore, TtlSessionStore, uuidv7, defaultTaskRegistry, createAllowDenyPolicy, workflowsCapability, probeSearchBackend, describeStaticWiring, expandTiers, DEFAULT_SUBAGENT_TOOL_NAME } from "@sema-agent/core";
+import { Runner, terminalProjection, createPermissionRuleStoreProvider, InMemoryToolResultStore, TtlSessionStore, uuidv7, defaultTaskRegistry, createAllowDenyPolicy, workflowsCapability, probeSearchBackend, describeStaticWiring, expandTiers, DEFAULT_SUBAGENT_TOOL_NAME } from "@sema-agent/core";
 import { createSessionTitler } from "./session-titler.js";
 import { posIntEnv } from "./session-watch.js";
 import { selectEnvironmentTool } from "./capabilities/select-environment-tool.js";
@@ -302,8 +302,10 @@ async function main() {
                 toolPolicy: createAllowDenyPolicy({}),
             });
             metrics.inc("hook_llm_calls_total", { type: "agent" });
-            if (result.status !== "completed")
-                return { ok: false, error: `hook agent ${result.status}: ${clipHookErr(result.errorMessage)}` };
+            if (result.terminal.kind !== "completed") {
+                const plane = terminalProjection(result.terminal);
+                return { ok: false, error: `hook agent ${plane.status}: ${clipHookErr(plane.errorMessage)}` };
+            }
             return { ok: true, text: result.result ?? "" };
         }
         catch (e) {

package/dist/observability/fail-open.d.ts

@@ -9,6 +9,14 @@ export interface FailOpenTagEntry {
 }
 /** 闭集 tag 词表。形=`<repo>.<domain>.<site>`(跨仓同形,便于三仓遥测并表)。 */
 export declare const FAIL_OPEN_TAGS: {
+    readonly "server.terminal.persisted-plane-malformed": {
+        readonly cls: "F";
+        readonly note: "S-136 合并重扫确认项(`terminal.ts persistedPlaneOf`,持久 blob 的平面读面):盘上一条 `terminal` 因由形不合(`paused` 缺 gate / 词出闭集)让 core 的 `terminalProjection` 抛 ⇒ 本读面对这一行答**全格缺席**而不是整只 500。放行的最坏后果=一条坏行在列表/舰队读面上显示为无终局词;计数 + probe 带原句,便于按行回溯。";
+    };
+    readonly "server.trace.gate-outcome-defective": {
+        readonly cls: "F";
+        readonly note: "S-136(core 7.6.0 design/390 S6-A,`trace/project.ts` 的 `screenedGate`,写腿与两条读腿共用):一条 `tool_end` / 账本行携带的 `GateOutcome` 过不了 core 的 `screenGateOutcome`(I1–I4 不变量,或某一格词出闭集)⇒ **整条 gate 记录不上帧**(report + withhold,core 契约逐字给出的两种响亮形之一;绝不「静默修补」成一条自洽的记录)。放行的最坏后果=这一帧的消费端渲染不出「谁拒的 / 那次等待怎么结束的」,退回到 `isError` + 文案;它**不改变任何裁决**(门早已在 core 里判完,这里只是观测面)。反方向(把一条自相矛盾的记录照发)更坏:消费端按 I2/I3 读出来的结论会是假的。计数让「某个世代的产生者一直在发坏记录」显形。";
+    };
     readonly "server.task-mcp.source-label-dropped": {
         readonly cls: "F";
         readonly note: "B-036 / S-143(`mcp-source-label.ts readMcpSourceLabel`,请求腿 + center 腿共用):`mcpServers[].source`(分组标签,显示用、开集)坏形——空串 / 超 80 字 / 非字符串——**丢键留 server**。放行的最坏后果=这台 server 在 wiring_manifest.mcp[] 里没有分组标签(难看),不是门/权限/凭证;本地 config.d 腿由 settings-schema 1.7.0 在解析处拒,故本臂只在请求腿与远端 /effective 直读 JSON 腿可达。";

package/dist/observability/fail-open.js

@@ -1,5 +1,13 @@
 import { appendFileSync } from "node:fs";
 export const FAIL_OPEN_TAGS = {
+    "server.terminal.persisted-plane-malformed": {
+        cls: "F",
+        note: "S-136 合并重扫确认项(`terminal.ts persistedPlaneOf`,持久 blob 的平面读面):盘上一条 `terminal` 因由形不合(`paused` 缺 gate / 词出闭集)让 core 的 `terminalProjection` 抛 ⇒ 本读面对这一行答**全格缺席**而不是整只 500。放行的最坏后果=一条坏行在列表/舰队读面上显示为无终局词;计数 + probe 带原句,便于按行回溯。",
+    },
+    "server.trace.gate-outcome-defective": {
+        cls: "F",
+        note: "S-136(core 7.6.0 design/390 S6-A,`trace/project.ts` 的 `screenedGate`,写腿与两条读腿共用):一条 `tool_end` / 账本行携带的 `GateOutcome` 过不了 core 的 `screenGateOutcome`(I1–I4 不变量,或某一格词出闭集)⇒ **整条 gate 记录不上帧**(report + withhold,core 契约逐字给出的两种响亮形之一;绝不「静默修补」成一条自洽的记录)。放行的最坏后果=这一帧的消费端渲染不出「谁拒的 / 那次等待怎么结束的」,退回到 `isError` + 文案;它**不改变任何裁决**(门早已在 core 里判完,这里只是观测面)。反方向(把一条自相矛盾的记录照发)更坏:消费端按 I2/I3 读出来的结论会是假的。计数让「某个世代的产生者一直在发坏记录」显形。",
+    },
     "server.task-mcp.source-label-dropped": {
         cls: "F",
         note: "B-036 / S-143(`mcp-source-label.ts readMcpSourceLabel`,请求腿 + center 腿共用):`mcpServers[].source`(分组标签,显示用、开集)坏形——空串 / 超 80 字 / 非字符串——**丢键留 server**。放行的最坏后果=这台 server 在 wiring_manifest.mcp[] 里没有分组标签(难看),不是门/权限/凭证;本地 config.d 腿由 settings-schema 1.7.0 在解析处拒,故本臂只在请求腿与远端 /effective 直读 JSON 腿可达。",

package/dist/observability/metrics.js

@@ -260,7 +260,7 @@ export function createMetrics() {
     m.counter("stale_cache_conflict_total", "Warm session-cache entries evicted by a cross-instance write while cached (S25)");
     m.counter("breaker_writethrough_failed_total", "Circuit-breaker cross-replica write-through failures (LOW), by backend");
     m.counter("web_search_bad_payload_total", "Web-search provider responses whose results field was not an array (LOW), by provider");
-    m.counter("permission_denied_total", "Tool-gate denials by source (core's PermissionDeniedSource, incl. org governance; 'other' = a word this build does not know; goal B4 always-on deny meter)");
+    m.counter("permission_denied_total", "Tool-gate denials by the LAYER whose verdict is the deny (core's DeniedBy: policy/hook/org/classifier/plan_mode/compliance/write_protection/ask_resolution; 'other' = this build cannot name the layer; label is `deniedBy` since server 7.64.0 — it was `source` over core's retired PermissionDeniedSource; goal B4 always-on deny meter)");
     m.counter("permission_rule_events_total", "Persisted allow-rule seam events by event (persisted_rule_allowed = a rule authorized a call with nobody asked; rule_store_unreadable = the store failed to read so the call was adjudicated with ZERO rules)");
     m.counter("compaction_events_total", "Compaction lifecycle events by outcome (started/completed/failed/skipped) and trigger");
     m.counter("hook_llm_calls_total", "prompt/agent hook entries that completed a model call (hooks 3b), by type");

package/dist/observability/run-terminal-log.d.ts

@@ -52,11 +52,26 @@ export declare const REDACT_INPUT_CAP = 65536;
  *  脱敏**之后**按字节封顶(占位已替换完,切在占位中间不是泄漏)并带标记。 */
 export declare const REDACT_OUTPUT_MAX_BYTES = 65000;
 export declare function redactErrorMessage(raw: string | undefined): string | undefined;
-/** 同口:终态 `result` 整块也持久化(`GET /v1/runs/:id` 直出 `result.errorMessage`)——写入前把内层 `errorMessage` 脱敏,
- *  其余键逐字不动;`undefined`/`null` 透传。 */
+/**
+ * 同口:终态 `result` 整块也持久化(`GET /v1/runs/:id` 直出),写入前把里面的**自由文本座**脱敏,其余键
+ * 逐字不动;`undefined`/`null` 透传。
+ *
+ * 🔴 S-136(core 7.6.0 [ref] D-8):自由文本座**搬家了** —— 失败文案与阻塞理由从顶层平面键
+ * (`errorMessage` / `blockedReason`)搬进因由 `terminal` 的两条臂(`failed.message` / `blocked.reason`)。
+ * 本函数**两种形都认**,而这不是「兼容读臂」(codex 对抗复审 r1 [high],亲读验真后**改判**;首版删掉了旧键
+ * 臂,那是错的):本函数是**读盘面**,而 `task_run.result` / `task_event(done).result` 里躺着 7.63.0 及以前
+ * 写下的**真字节**,它们本来就是平面形。写口只剩因由一条(没有任何东西会再写出旧形),所以这里不存在
+ * 「两个写者」;而不认旧形的代价是**可复现的凭据回放**:上线前落盘的原文经 `GET /v1/runs/:id/events` 重新
+ * 明文外发(读面这一层纵深正是为那批行存在的)。⇒ 规则仍只有一条:**读盘认盘上真有的形,写盘只写一种形**。
+ *
+ * 读面也走本函数,所以 `terminal` 形上取 `unknown`:旧持久 blob 与非 core 的 Runner 实现给的形不可信,
+ * 运行期逐臂判形、不抛(与 `remoteEnvFailures` / `editedFiles` 两座同款不信任)。
+ */
 export declare function redactTerminalResult<T extends {
-    errorMessage?: string | undefined;
-    blockedReason?: string | undefined;
+    terminal?: unknown;
+    /** 旧形(≤7.63.0)的两个顶层自由文本座;形上取 `unknown` —— 读盘面对盘上字节不作假设。 */
+    errorMessage?: unknown;
+    blockedReason?: unknown;
     remoteEnvFailures?: readonly {
         message?: string | undefined;
     }[] | undefined;
@@ -114,9 +129,12 @@ export declare function redactLeaderResultWithFlag(result: unknown): {
     changed: boolean;
 };
 export declare function memoRedactedRead<T>(seat: string, raw: T, redact: (v: T) => T): T;
-/** run 终态 result 的读面记忆只按**可脱敏的三叶**(errorMessage / blockedReason / remoteEnvFailures[].message)做键与留体——
- *  第十六轮重扫:按整块 result 摘要每次轮询要 stringify 一份可能数 MB 的 result,且大 result 的脏行永远存不进去。三叶缺席
- *  ⇒ O(1) 直返(`redactTerminalResult` 本就同引用)。 */
+/** run 终态 result 的读面记忆只按**可脱敏的那几叶**(`terminal` 的自由文本臂 / 旧形的两个顶层座 /
+ *  `remoteEnvFailures[].message`)做键与留体——
+ *  第十六轮重扫:按整块 result 摘要每次轮询要 stringify 一份可能数 MB 的 result,且大 result 的脏行永远存不进去。两叶缺席
+ *  ⇒ O(1) 直返(`redactTerminalResult` 本就同引用)。
+ *  🔴 S-136(core 7.6.0 D-8):新形把前两片搬进了 `terminal`(同属一个键,按它整只做叶更省);旧形的两片
+ *  **照留**——盘上真有那样的行,而读面纵深正是为它们存在的(codex 对抗复审 r1 [high] 验真后补)。 */
 export declare function memoRedactTerminalResult<T extends Parameters<typeof redactTerminalResult>[0]>(seat: string, result: T): T;
 export declare function diffScanShadowCountForTest(): number;
 export declare function resetDiffScanShadowCountForTest(): void;

package/dist/observability/run-terminal-log.js

@@ -81,14 +81,25 @@ export function redactTerminalResult(result) {
     const r = result;
     let changed = false;
     const out = { ...r };
-    if (r.errorMessage !== undefined) {
+    if (typeof r.errorMessage === "string") {
         out.errorMessage = redactErrorMessage(r.errorMessage);
         changed = true;
     }
-    if (r.blockedReason !== undefined) {
+    if (typeof r.blockedReason === "string") {
         out.blockedReason = redactErrorMessage(r.blockedReason);
         changed = true;
     }
+    if (r.terminal !== null && typeof r.terminal === "object") {
+        const t = r.terminal;
+        if (t.kind === "failed" && typeof t.message === "string") {
+            out.terminal = { ...t, message: redactErrorMessage(t.message) };
+            changed = true;
+        }
+        else if (t.kind === "blocked" && typeof t.reason === "string") {
+            out.terminal = { ...t, reason: redactErrorMessage(t.reason) };
+            changed = true;
+        }
+    }
     if (r.remoteEnvFailures !== undefined) {
         out.remoteEnvFailures = Array.isArray(r.remoteEnvFailures)
             ? r.remoteEnvFailures.map((f) => (f && typeof f === "object" && typeof f.message === "string" ? { ...f, message: redactErrorMessage(f.message) } : f))
@@ -355,9 +366,9 @@ export function memoRedactTerminalResult(seat, result) {
     if (result === undefined || result === null)
         return result;
     const r = result;
-    if (r.errorMessage === undefined && r.blockedReason === undefined && r.remoteEnvFailures === undefined)
+    if (r.terminal === undefined && r.errorMessage === undefined && r.blockedReason === undefined && r.remoteEnvFailures === undefined)
         return result;
-    const leaves = { errorMessage: r.errorMessage, blockedReason: r.blockedReason, remoteEnvFailures: r.remoteEnvFailures };
+    const leaves = { terminal: r.terminal, errorMessage: r.errorMessage, blockedReason: r.blockedReason, remoteEnvFailures: r.remoteEnvFailures };
     const redacted = memoRedactedRead(seat, leaves, (l) => redactTerminalResult(l));
     if (redacted === leaves)
         return result;

package/dist/observability/tool-trace.d.ts

@@ -1,18 +1,19 @@
-import type { Hooks, PermissionDeniedSource } from "@sema-agent/core";
+import { type Hooks } from "@sema-agent/core";
 import type { Logger } from "./logger.js";
 import type { Metrics } from "./metrics.js";
-/** 表内 ⇒ 收窄成 `PermissionDeniedSource`(类型守卫)。计量点用它判「这个词是不是本 build 认得的真词」。
- *  导出是为了让运行期锚(`test/tool-trace.test.ts`,从装树 core 的 `.d.ts` 解析真词表)**复用同一个谓词**
- *  —— 测试自己另写一份判据 = 又一张手抄表,正是本文件刚消灭的那个病。 */
-export declare function isKnownDenySource(v: unknown): v is PermissionDeniedSource;
 /**
- * ALWAYS-ON gate-deny meter (goal B4, 2026-07-08): `permission_denied_total{source}` — how often the
- * adjudicate chain DENIES a tool call, by gate source. Deliberately SEPARATE from {@link createToolTracer}:
- * the tracer is a default-OFF diagnostic (TOOL_TRACE=true), but deny frequency is an operational/security
- * signal that must reach /metrics on every deployment — a spike in `source="policy"` means a task keeps
- * asking for something the operator forbids; `source="safety"`/`"shellGate"` spikes flag risky-command
- * pressure. main.ts composes this UNDER the tracer via composeHooks (both are void observers on the
- * permissionDenied slot, which composeHooks double-runs deployment-first).
+ * ALWAYS-ON gate-deny meter (goal B4, 2026-07-08): `permission_denied_total{deniedBy}` — how often the
+ * adjudicate chain DENIES a tool call, by the LAYER whose verdict is the deny. Deliberately SEPARATE from
+ * {@link createToolTracer}: the tracer is a default-OFF diagnostic (TOOL_TRACE=true), but deny frequency is an
+ * operational/security signal that must reach /metrics on every deployment — a spike in `deniedBy="policy"`
+ * means a task keeps asking for something the operator forbids; `deniedBy="org"` is the organization layer
+ * refusing, the one class an operator most wants to see on its own. main.ts composes this UNDER the tracer via
+ * composeHooks (both are void observers on the permissionDenied slot, which composeHooks double-runs
+ * deployment-first).
+ *
+ * 🔴 BREAKING(server 7.64.0,core 7.6.0 提货):标签名 `source` → `deniedBy`,词表从七词
+ * (`policy/hook/safety/shellGate/planMode/classifier/org`)换成八词
+ * (`policy/hook/org/classifier/plan_mode/compliance/write_protection/ask_resolution`)。仪表盘/告警规则要改。
  */
 export declare function createPermissionDeniedMeter(metrics: Pick<Metrics, "inc">): Hooks;
 /**

package/dist/observability/tool-trace.js

@@ -1,20 +1,13 @@
+import { isDeniedBy } from "@sema-agent/core";
 import { redactSecrets } from "../trace/redact.js";
-const KNOWN_DENY_SOURCE_TABLE = {
-    policy: true,
-    hook: true,
-    safety: true,
-    shellGate: true,
-    planMode: true,
-    classifier: true,
-    org: true,
-};
-export function isKnownDenySource(v) {
-    return typeof v === "string" && Object.hasOwn(KNOWN_DENY_SOURCE_TABLE, v);
+function deniedByLabel(gate) {
+    const d = gate.disposition;
+    return d.kind === "denied" && isDeniedBy(d.deniedBy) ? d.deniedBy : "other";
 }
 export function createPermissionDeniedMeter(metrics) {
     return {
         permissionDenied(payload) {
-            metrics.inc("permission_denied_total", { source: isKnownDenySource(payload.source) ? payload.source : "other" });
+            metrics.inc("permission_denied_total", { deniedBy: deniedByLabel(payload.gate) });
         },
     };
 }
@@ -52,7 +45,9 @@ export function createToolTracer(logger) {
                 phase: "denied",
                 id: payload.toolCallId,
                 tool: payload.toolName,
-                source: payload.source,
+                deniedBy: deniedByLabel(payload.gate),
+                ...(payload.gate.origin === undefined ? {} : { origin: payload.gate.origin }),
+                ...(payload.gate.settlement === undefined ? {} : { settlement: payload.gate.settlement.kind }),
                 reason: clip(redactSecrets(payload.reason), 200),
                 arg: summarize(payload.input),
             });

package/dist/parked-decide.d.ts

@@ -8,7 +8,8 @@
  * 判别必须 parked-first:legacy 腿的 `resumeStream` 会绕开 bg registry(无 consumeParkedFlip、
  * 行永 parked、生命周期分叉)。
  */
-import type { ApprovalSettledBy, BackgroundAgentRecord, BackgroundAgentStore, CheckpointStore, QuestionAnswer, TaskRegistry, ToolSpec } from "@sema-agent/core";
+import type { HostDecision } from "./host-decision.js";
+import type { BackgroundAgentRecord, BackgroundAgentStore, CheckpointStore, QuestionAnswer, TaskRegistry, ToolSpec } from "@sema-agent/core";
 export interface ParkedAgentMatch {
     handle: string;
     row: BackgroundAgentRecord;
@@ -64,11 +65,14 @@ export interface ParkedDecideRequest {
     /** cp.pendingAction 原样(outcome 铸造的 persisted 回落源,与 legacy 腿 D-1 姿势逐字同形)。 */
     pendingAction: unknown;
     decision: "approve" | "deny";
-    /** [ref] 件6③ core `ApprovalSettledBy`:**这次结算的出处**,由调用方命名(必填,理由与 legacy 腿
+    /** [ref] 件6③ / S-136(core 7.6.0 S6-A):**这次结算的事实**,由调用方陈述(必填,理由与 legacy 腿
      *  `resumeCheckpoint` 的同名参数逐字同源 —— 本函数分辨不出谁在叫它,漏报要是编译错而不是假出处)。
+     *  🔴 宿主报**事实**(谁结束的 + 通道自报的归属),core 铸**词**:`human_allowed` / `human_refused` /
+     *  `park_sla_expired` 由 core 在 resume 入口铸出来,写进行的 `resolvedOutcome.gateOutcome` 与那次调用的
+     *  `tool_end.gate`。server 一个结算词都不再拼(core 对宿主自铸的词是 pre-CAS 响亮拒)。
      *  今天唯一的调用方是 `server.ts` 的人为 `/decide`(那道门写着 `req !== undefined`,而内部 D-D SLA
-     *  deny-sweep 恰是 req 缺席的那条腿,它对 parked 行另有静默跳过臂)⇒ 恒 `"human"`。 */
-    settledBy: ApprovalSettledBy;
+     *  deny-sweep 恰是 req 缺席的那条腿,它对 parked 行另有静默跳过臂)⇒ 恒 `decidedBy:"person"`。 */
+    hostDecision: HostDecision;
     reason?: string;
     /** D-1 decision-binding echo(操作员在 GET 看到的 boundCallId/boundInputHash 原样透传;server
      *  绝不重算,core resume 侧做 fail-closed 等值校验——与 legacy 腿同姿势)。 */

package/dist/parked-decide.js

@@ -92,7 +92,7 @@ export async function decideParkedAgent(deps, req) {
         ...(req.decision === "approve" && req.binding?.updatedInput !== undefined ? { updatedInput: req.binding.updatedInput } : {}),
         ...(req.answer !== undefined ? { answer: req.answer } : {}),
         ...(req.reason !== undefined ? { reason: req.reason } : {}),
-        settledBy: req.settledBy,
+        hostDecision: req.hostDecision,
     };
     const ctx = {
         toolCallId: `drv-${ticket.claimId}`,