@sema-agent/server 7.115.0 → 7.116.0

package/dist/http/routes/workflows.js

@@ -12,6 +12,7 @@ const journalProjectionMemo = new Map();
 import { sendJson, sendError, sseHeaders } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
+import * as facts from "../../capability-facts.js";
 export async function handleWorkflows(req, res, match, ctx) {
     const { deps } = ctx;
     const { runSessionAcceptOk } = ctx.helpers;
@@ -21,10 +22,21 @@ export async function handleWorkflows(req, res, match, ctx) {
             sendPrincipalRefusal(res, req, deps.config);
             return;
         }
-        if (!deps.workflowRunStore) {
-            sendError(res, 501, "capability.self_orchestration_required", "workflow runs require self-orchestration (SELF_ORCHESTRATION_ENABLED)");
+        let journalStore;
+        if (match.decl.id === "workflow-journal") {
+            const journalFace = facts.workflowsJournal(deps);
+            if (!journalFace.available) {
+                sendWorkflowsUnavailable(res, journalFace.why);
+                return;
+            }
+            journalStore = journalFace.journal;
+        }
+        const runs = facts.workflowRuns(deps);
+        if (!runs.available) {
+            sendWorkflowsUnavailable(res, runs.why);
             return;
         }
+        const runStore = runs.store;
         const scope = principal ?? "default";
         const wfId = match.params.runId;
         const isStream = match.decl.id === "workflow-stream";
@@ -33,7 +45,7 @@ export async function handleWorkflows(req, res, match, ctx) {
             const statusFilter = q.get("status");
             const limit = Math.min(100, Math.max(1, Number(q.get("limit") ?? 50) || 50));
             const sessionFilter = q.get("session");
-            const sessionRuns = await deps.workflowRunStore.listByScope(scope, {
+            const sessionRuns = await runStore.listByScope(scope, {
                 ...(statusFilter ? { status: statusFilter } : {}),
                 limit,
                 ...(sessionFilter !== null ? { session: sessionFilter } : {}),
@@ -47,7 +59,7 @@ export async function handleWorkflows(req, res, match, ctx) {
             sendJson(res, 200, { workflows: redacted });
             return;
         }
-        const run = await getWorkflowRun(deps.workflowRunStore, wfId, scope);
+        const run = await getWorkflowRun(runStore, wfId, scope);
         if (!run || run.scope !== scope) {
             sendError(res, 404, "not_found.workflow", "workflow not found");
             return;
@@ -55,10 +67,8 @@ export async function handleWorkflows(req, res, match, ctx) {
         if (!runSessionAcceptOk(req, res, { sessionId: run.originatingSessionId ?? null }, match.decl.id === "workflow-journal" ? "workflow.journal" : isStream ? "workflow.stream" : "workflow.detail", "workflow not found"))
             return;
         if (match.decl.id === "workflow-journal") {
-            if (!deps.workflowJournalStore) {
-                sendError(res, 501, "capability.workflow_store_required", "workflow journal requires the journal store (SELF_ORCHESTRATION_ENABLED + a store backend)");
-                return;
-            }
+            if (journalStore === undefined)
+                throw new Error("workflow-journal reached without the workflowsJournal journal witness");
             const jq = new URLSearchParams(match.search);
             const jLimit = Math.min(50, Math.max(1, Number(jq.get("limit") ?? 20) || 20));
             const jOffset = Math.max(0, Number(jq.get("offset") ?? 0) || 0);
@@ -100,7 +110,7 @@ export async function handleWorkflows(req, res, match, ctx) {
                     ...(r.haltedOnUserRejection === true ? { haltedOnUserRejection: true } : {}),
                 };
             };
-            const js = deps.workflowJournalStore;
+            const js = journalStore;
             let projected;
             if (js.loadPage) {
                 const page = await js.loadPage(wfId, scope, { offset: jOffset, limit: jLimit, maxResultBytes: MAX_ROW_BYTES });
@@ -118,7 +128,7 @@ export async function handleWorkflows(req, res, match, ctx) {
                 });
             }
             else {
-                const entries = await deps.workflowJournalStore.load(wfId, scope);
+                const entries = await journalStore.load(wfId, scope);
                 projected = entries
                     .sort((a, b) => callKeyOrdinal(a.callKey) - callKeyOrdinal(b.callKey))
                     .slice(jOffset, jOffset + jLimit)
@@ -150,8 +160,9 @@ export async function handleWorkflowAgentSteer(req, res, match, ctx) {
     {
         if (rateLimited(req, res) || quotaExceeded(req, res) || (await leaseDenied(req, res)))
             return;
-        if (!deps.workflowRunStore) {
-            sendError(res, 501, "capability.self_orchestration_required", "workflow runs require self-orchestration (SELF_ORCHESTRATION_ENABLED)");
+        const runs = facts.workflowRuns(deps);
+        if (!runs.available) {
+            sendWorkflowsUnavailable(res, runs.why);
             return;
         }
         const principal = gatedPrincipal(req, deps.config);
@@ -183,7 +194,7 @@ export async function handleWorkflowAgentSteer(req, res, match, ctx) {
         }
         const trusted = explicitOperatorOk(principal, deps.config.operatorPrincipals);
         const ownerScope = principal ?? "default";
-        const wfRun = await getWorkflowRun(deps.workflowRunStore, wfRunId, ownerScope);
+        const wfRun = await getWorkflowRun(runs.store, wfRunId, ownerScope);
         if (!trusted && !wfRun) {
             sendError(res, 404, "not_found.workflow", "workflow not found");
             return;
@@ -389,6 +400,18 @@ async function streamWorkflowRun(req, res, runId, scope) {
     if (!res.writableEnded)
         res.end();
 }
+function sendWorkflowsUnavailable(res, why) {
+    switch (why) {
+        case "workflow_run_store_absent":
+            sendError(res, 501, "capability.self_orchestration_required", "workflow runs require self-orchestration (SELF_ORCHESTRATION_ENABLED)");
+            return;
+        case "workflow_journal_store_absent":
+            sendError(res, 501, "capability.workflow_store_required", "workflow journal requires the journal store (SELF_ORCHESTRATION_ENABLED + a store backend)");
+            return;
+        default:
+            return assertNever(why);
+    }
+}
 export const WORKFLOWS_ROUTES = [
     { id: "workflows-list", path: "/v1/workflows", methods: ["GET"] },
     { id: "workflow-stream", pattern: /^\/v1\/workflows\/(?<runId>[^/]+)\/stream$/, label: "/v1/workflows/:id/$sub", methods: ["GET"] },

package/dist/http/server.js

@@ -23,6 +23,7 @@ import { sendError, sendSessionError, httpErrorCode, msg } from "./send.js";
 import { createRequestGuards } from "./request-guards.js";
 import { createAdmission, MAX_SKILL_CONTENT_CHARS, MAX_SYSTEM_PROMPT_CHARS, MAX_OUTPUT_SCHEMA_CHARS, validateUserSkills } from "./admission.js";
 import { createResumeLegs } from "./resume-legs.js";
+import * as facts from "../capability-facts.js";
 import { createDispatch, hasServiceAuth } from "./dispatch.js";
 import { routeLabel, isBillableSubmitPath, isCredentialGatedRewrite, isMethodDispatchedSubmitPath, isProbePath } from "./route-table.js";
 import { createApprovalSweeps } from "./approval-sweeps.js";
@@ -118,7 +119,9 @@ export function createHttpServer(rawDeps) {
             sendError(res, 500, "internal.error", "internal error");
         });
     });
-    deps.deviceHub?.attach(server);
+    const deviceLane = facts.deviceLane(deps);
+    if (deviceLane.available)
+        deviceLane.hub.attach(server);
     function runnerFor(spec) {
         return deps.runnerFor(spec);
     }

package/dist/http/wire-types.d.ts

@@ -301,6 +301,12 @@ export interface TaskRequestBody {
      *  续跑重放逐字重放存量体 ⇒ 同一只写点同判(坏形 defensive:只认 literal `true`)。无租户门(收窄,不跨租户)。
      *  探测位 `GET /v1/capabilities` 的 `disableSkills`(与本键同一个词)。 */
     disableSkills?: boolean;
+    /** core 7.41.0 #1303 —— **人用名字点过的技能**(壳从人敲的 `/name` 解析出来的,按 `SkillSpec.name`),原样交给 core 的
+     *  `TaskSpec.userInvokedSkills`:这些技能的 `allowedTools` / `disallowedTools` 开跑即生效,不出 `Skill` 卡(人自己点的名就是那句表态),
+     *  只管这一次 run(steer 不终止它,下一次 run 不带)。每个名字必须是这一 run 装着的技能(场景出厂 ∪ 本请求 `skills`),否则引擎
+     *  拒启 `config.user_invoked_skill_unknown`(同步腿 400)。值形:非空串数组(受理门 400 `request.field_invalid`);续跑重放逐字重放存量体,
+     *  坏形不挂键。不投递技能正文(正文照旧由 `Skill` 工具 / 调用方负责)。 */
+    userInvokedSkills?: string[];
     /** [ref]② (core 1.314 工具面控制批): roster 真卸载清单(schema 不上 wire,manifest 收窄)。wire 工具名;
      *  tighten-only(core 继承不变量 union 进子 spawn)。数组-of-string fail-loud at submit。 */
     excludeTools?: string[];

package/dist/namespaced-rule-name.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 协议规则名(`mcp__…` / `a2a__…`)够不够得着一只挂载工具 —— **一只**判官 + **一只**句子。调它的面(点名,不是「每个面」):
+ *  · 运维四表与中心下发的同名表、请求 `settings.permissions.{allow,ask,deny}`(经 `config.ts` 的 `unmatchableToolNamesRefusal`);
+ *  · 会话规则写口两腿与 SQL 会话规则店的写口(经 `session-policy-wire.ts`);
+ *  · 技能的两只清单 `allowedTools` / `disallowedTools`,两处受理口:顶层 `skills[]`(`http/admission.ts` 的 `validateUserSkills`)与子代
+ *    `agents[].skills[]`(`spec-fields.ts` 的 `validateTaskAgents`),经 `spec-fields.ts` 的 `unreachableSkillToolListEntryOf`。
+ * **不调它的面**(如实,未接):`/v1/rules` 的持久规则写口与 `cc-import` 导入口(`http/routes/rules.ts`)、子代的工具名表 `agents[].allowTools` /
+ * `denyTools`(`spec-fields.ts` 只判形与条数)。在这两处写铸不出的服务器段仍被收下、永不命中。
+ * 规则文本里「工具名那一段」怎么取也只有一种读法:{@link ruleEntryToolName}(配置表与技能清单同读)。
+ *
+ * 规则:一条协议规则名够得着挂载工具 ⇔
+ *  ① 分得出对端段 —— 三段名(`ns.parse` 认得:首段为对端、余段非空)取 `parse().peer`;两段覆盖形 `<ns>__<peer>`(core `isNamespacedCoveringRuleName`
+ *     认、`ns.parse` 不认)取前缀之后的整段;两者都不是(`mcp__` / `mcp__srv__` / `mcp____x`)= **缺段**;
+ *  ② 对端段是引擎**自铸**的那一段:`mintNamespacePrefix(ns, peer) === ns.prefix + peer + "__"`。引擎铸注册名时归一对端段(字符表外换 `_`、超长截断加摘要、
+ *     折连串下划线、去尾下划线),而规则匹配对对端段逐字比(覆盖形 `namespacedRuleNameCovers`,精确名整串比)—— 铸不出的对端段一只工具都匹配不到。
+ *     服务器段里带 `*`(`mcp__*`、`mcp__git*__x`)是同一个「够不着」,但出路不同:那是在写通配,而服务器名不支持通配 —— 给一条铸名写法
+ *     (`mcp__<摘要>__*`)没人照做得了 ⇒ 判词单列 `wildcard_peer`,句子说实话(写具体的服务器名)。
+ * 判据不看规则是覆盖形还是精确名:两种形的对端段命运相同。精确名的**工具段**归一不在这里判(包根没有导出工具段的铸法,不手抄)。
+ *
+ * core 下一版(7.42.0)的规则名判官会自己给这个判词;到货那天本仓这只对照整只退役(连同会话规则写口这一问的码由 `request.field_invalid` 归回
+ * `rules.legacy_tool_name`)。
+ */
+import { type ProtocolNamespace } from "@sema-agent/core";
+/**
+ * 一条**规则文本**里的工具名那一段(判官与旧名判据的主语)= core 包根 `parsePermissionRule` 的 `toolName`,原样 —— 引擎的技能编译器
+ * (`compileSkillGrant`)与规则编译器读条目用的就是这一只:`Bash(npm:*)` ⇒ `Bash`;`mcp__srv(*)` / `mcp__srv()` / 带首尾空格的 `mcp__srv ` ⇒ 光杆名 `mcp__srv`。
+ * 配置表的规则编译器消费者与技能的两只清单读同一只。不在这里另写解析、不回落整串:修前用 `parseRuleText`(只认 `工具(内容)` 形,光杆名解析不出就回落整串),
+ * 整串带着 `(*)` / 尾空格进判官 ⇒ 合法条目被判「铸不出」(修复验证轮 gpt-6 腿)。条目若是引擎文法本身就拒的形(配置表上 MCP 规则带括号:
+ * `unsupported.mcp_paren`),拒由引擎的文法那一问说(配置表的判据链里它排在本判官之前),本判官不抢答。
+ */
+export declare function ruleEntryToolName(entry: string): string;
+/** 一条协议规则名够不着任何挂载工具的判词(闭集)。 */
+export type UnreachableNamespacedRuleName = 
+/** 分不出对端段:光杆前缀、对端段为空、或分隔符之后工具段为空。 */
+{
+    readonly kind: "incomplete";
+    readonly ns: ProtocolNamespace;
+}
+/** 对端段不是引擎自铸的那一段;`minted` = 引擎为这样一个对端名铸出的注册名前缀(`mintNamespacePrefix` 的返回值,原样)。 */
+ | {
+    readonly kind: "unminted_peer";
+    readonly ns: ProtocolNamespace;
+    readonly minted: string;
+}
+/** 对端段里带 `*`:写的是通配,而服务器 / 对端名不支持通配(规则对这一段逐字比)。 */
+ | {
+    readonly kind: "wildcard_peer";
+    readonly ns: ProtocolNamespace;
+};
+/** 判官:不是协议名、或够得着 ⇒ `undefined`;否则给判词。纯字符串运算,不做 I/O。 */
+export declare function unreachableNamespacedRuleNameOf(name: string): UnreachableNamespacedRuleName | undefined;
+/** 判词 → 句子(「为什么永远匹配不到 + 怎么写」;不复述条目本身 —— 调用方的句子已点名它)。闭集穷尽:判词加一种 ⇒ 编译红。 */
+export declare function describeUnreachableNamespacedRuleName(v: UnreachableNamespacedRuleName): string;
+//# sourceMappingURL=namespaced-rule-name.d.ts.map

package/dist/namespaced-rule-name.js

@@ -0,0 +1,33 @@
+import { isNamespacedCoveringRuleName, mintNamespacePrefix, parsePermissionRule, protocolOf } from "@sema-agent/core";
+export function ruleEntryToolName(entry) {
+    return parsePermissionRule(entry).toolName;
+}
+export function unreachableNamespacedRuleNameOf(name) {
+    const ns = protocolOf(name);
+    if (ns === undefined)
+        return undefined;
+    const peer = ns.parse(name)?.peer ?? (isNamespacedCoveringRuleName(name) ? name.slice(ns.prefix.length) : undefined);
+    if (peer === undefined)
+        return { kind: "incomplete", ns };
+    if (peer.includes("*"))
+        return { kind: "wildcard_peer", ns };
+    const minted = mintNamespacePrefix(ns, peer);
+    return minted === `${ns.prefix}${peer}__` ? undefined : { kind: "unminted_peer", ns, minted };
+}
+export function describeUnreachableNamespacedRuleName(v) {
+    switch (v.kind) {
+        case "incomplete":
+            return `incomplete ${v.ns.id} name — the live form is ${v.ns.prefix}<server>__<tool>, or ${v.ns.prefix}<server> / ${v.ns.prefix}<server>__* to cover every tool on that server`;
+        case "wildcard_peer":
+            return `the ${v.ns.id} server segment does not take a wildcard — a rule compares the server segment literally, so the entry matches nothing; write the concrete server name: ${v.ns.prefix}<server>__* to cover every tool on that server, or ${v.ns.prefix}<server>__<tool>`;
+        case "unminted_peer":
+            return (`the engine never mints this server segment as written — a server configured under that name has its tools registered as ${v.minted}<tool>, ` +
+                `and a rule compares the server segment literally (no wildcard, no normalization), so the entry matches nothing; if that is the configured name, ` +
+                `write ${v.minted}* to cover every tool on that server, or ${v.minted}<tool>`);
+        default: {
+            const unhandled = v;
+            throw new Error(`unhandled namespaced rule name verdict: ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
+//# sourceMappingURL=namespaced-rule-name.js.map

package/dist/observability/corrupt-read-seat.d.ts

@@ -43,9 +43,10 @@ export declare function createCorruptReadFailOpenSeat(tag: FailOpenTag, leg?: (i
  *
  * ## 逐命中响亮不降级
  * 这一座里有安全轴的脸(session-policy),所以每命中一行 warn 保留(降成「每进程一次」是降级,S-990 的裁定);**在此之上**,认出的脸另记账:
- *  · session-policy 脸 ⇒ `P-DEBT` tag(`server.session-policy.corrupt-read-fail-open`)—— 计数逐次 + 探针行 + 一次性 warn。core 7.39.2 起按键读拒,
- *    但枚举 / 别的会话抹除 / 数据根重绑三张脸仍按「无规则」(会话规则只许收紧 ⇒ 丢的恰是收紧);座上分不出读法 ⇒ 这一脸每一发都计(含已拒的按键读)。
- *    别的会话抹除的常见形 core **不披露** ⇒ 这一形座上数不到,只能在 CENSUS / CHANGELOG 披露。放行是 core 的裁定、本仓不包层(源头修复纪律),所以**只登债、不改放行**;
+ *  · session-policy 脸 ⇒ `P-DEBT` tag(`server.session-policy.corrupt-read-fail-open`)—— 计数逐次 + 探针行 + 一次性 warn。core 7.39.2 起按键读拒;
+ *    core 7.41.0 #1309 起本会话的枚举拒、别的会话的抹除不动它、重绑带走它 —— 但只对**有归属**的坏行(行里的 `__sid`,否则同名高水位标记的 `__sid`);
+ *    无归属的坏行仍按「无规则」(会话规则只许收紧 ⇒ 丢的恰是收紧);座上分不出读法 ⇒ 这一脸每一发都计(含已拒的)。
+ *    抹除扫走无归属坏行那一形 core 是否披露、座上数不数得到,本车未亲核(未闭环,收车档登)。放行是 core 的裁定、本仓不包层(源头修复纪律),所以**只登债、不改放行**;
  *  · 其余脸 ⇒ 不计(见 {@link DurableAbsenceFace})。
  * 记账**先于** warn:记账是总函数,warn 可能抛(core 的 guard 会吞掉那个抛),一次日志故障不许吃掉计数。
  *

package/dist/observability/corrupt-read-seat.js

@@ -86,9 +86,10 @@ export function createDurableAbsenceSeat(warn, root, thirdFace) {
 }
 function buildDurableAbsenceNote(thirdFace) {
     return ("a durable read hit unreadable bytes (never a plain ENOENT). " +
-        "Consequence depends on which store read it: session-policy = a keyed read (a task's session rules, GET/PUT .../policy) was REFUSED " +
-        "(the run fails with code \"corrupt\"), but enumeration (session sync export), another session's erase sweep and a data-root rebind still " +
-        "read that row as NO RULES — fix or delete the named file (deleting it means no session rules); session repo = a listing silently " +
+        "Consequence depends on which store read it: session-policy = a keyed read and this session's enumeration (a task's session rules, " +
+        "GET/PUT .../policy, the session sync export) were REFUSED (code \"corrupt\"); another session's erase keeps the row and a data-root rebind carries it, " +
+        "but a damaged row nothing on disk attributes to a session (no session id in its bytes and no high-water mark beside it) is still omitted from listings, " +
+        "swept by any session's erase when it is not JSON and left behind by a rebind, i.e. read as NO RULES — fix or delete the named file (deleting it means no session rules); session repo = a listing silently " +
         `omitted rows; ${thirdFace}. Inspect the named path before deciding.`);
 }
 const RULE_LANE_REMEDY = "the permission-rule lane is fail-closed until a person inspects the file (moving it aside restarts the lane with an empty log)";

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

@@ -368,7 +368,11 @@ export declare const FAIL_OPEN_TAGS: {
     };
     readonly "server.session-policy.corrupt-read-fail-open": {
         readonly cls: "P-DEBT";
-        readonly note: "S-999(`observability/corrupt-read-seat.ts` 的 `createDurableAbsenceSeat`,`file_store_corrupt_read` 那只多脸座里认出的 **session-policy 脸**;local 车道,HTTP 服务的 local 腿与 run-local 同铸点):会话规则文件(数据根 `session-policy/` 下的行文件)坏了。core 7.39.2(#1299,本仓请托)起**按键读**(任务装规则、`GET` / `PUT /v1/sessions/:id/policy`)拒 —— `SessionPolicyError` 码 `corrupt`;但 core 包内 CHANGELOG 自陈另三张脸仍把坏行读成「无规则」:① `listBySession` 跳过坏行(会话同步导出读它 ⇒ 导出里没有这位 principal 的规则,目标端按无规则跑);② 别的会话的 `deleteBySession` 把撕尾行一并扫掉(常见形**不披露**),此后按键读得 ENOENT = 无规则;③ 数据根重绑把撕尾行留在旧键下。会话规则**只许收紧** ⇒ 丢的恰是调用方加的收紧(部署策略 / hooks / shell 门仍在)。方向 = fail-open,**明知不对**;SQL 孪生(`plugins/session-policy-store-sql.ts`)对同形响亮抛(CENSUS 第 81 行 P 终态)。归 P 类的理由是它决定权限门读到的规则层;归 DEBT 的理由是放行是 **core 的裁定**,源头修复纪律下本仓不包层,只让债在遥测里显形:计数逐次 + 探针行(`kind` / `path` / `sessionId` / `principal` / `reason`)+ 一次性 warn;逐命中 warn(`file_store_corrupt_read`)原样保留。⚠️ **如实全记**:座上分不出是哪一只读法披露的(载荷不带读法),所以这一脸的每一发都计 —— 含已被拒的按键读(那一发本身是 fail-closed);② 的常见形 core 不披露,座上**数不到**。**出路 = core 把三张脸也改成拒,届时撤本 tag**。计数非零 = 有会话的规则文件坏了:运维按探针里的 `sessionId` / `path` 去修(删文件即放弃那层规则,删前先看 `reason`)。认脸判据见 `durableAbsenceFaceOf`(披露路径落在本数据根的 `session-policy/` 之下);认不出的脸不计。7.114.0 合流时车 UY 曾以「core 已修」整只撤掉本 tag,修复轮恢复(那次删除未发版)。";
+        readonly note: "S-999(`observability/corrupt-read-seat.ts` 的 `createDurableAbsenceSeat`,`file_store_corrupt_read` 那只多脸座里认出的 **session-policy 脸**;local 车道,HTTP 服务的 local 腿与 run-local 同铸点):会话规则文件(数据根 `session-policy/` 下的行文件)坏了。core 7.39.2(#1299,本仓请托)起**按键读**(任务装规则、`GET` / `PUT /v1/sessions/:id/policy`)拒 —— `SessionPolicyError` 码 `corrupt`;core 7.41.0(#1309)起另三张脸对**有归属**的坏行(行里的 `__sid`,否则同名高水位标记的 `__sid`)也收紧了:① 本会话的 `listBySession` 拒(`corrupt`;会话同步导出 `GET /v1/sessions/:id/sync/manifest` 转 500 `corrupt`);② 别的会话的 `deleteBySession` 不动它;③ 数据根重绑带走它(新键上按键读照拒)。**仍按「无规则」的只剩无归属的坏行**(行里读不出 `__sid`、同名高水位标记也不在;core 包内 CHANGELOG 逐字「keeps its old fate」):枚举略过并披露、它「根本不是 JSON」时被任一会话的抹除扫掉(此后按键读得 ENOENT = 无规则)、重绑留在旧键下 —— 钉 `test/corrupt-read-f-seats-s990.test.ts` 的 🚧「S-1016 残余」格。会话规则**只许收紧** ⇒ 丢的恰是调用方加的收紧(部署策略 / hooks / shell 门仍在)。方向 = fail-open,**明知不对**;SQL 孪生(`plugins/session-policy-store-sql.ts`)对同形响亮抛(CENSUS 第 81 行 P 终态)。归 P 类的理由是它决定权限门读到的规则层;归 DEBT 的理由是放行是 **core 的裁定**,源头修复纪律下本仓不包层,只让债在遥测里显形:计数逐次 + 探针行(`kind` / `path` / `sessionId` / `principal` / `reason`)+ 一次性 warn;逐命中 warn(`file_store_corrupt_read`)原样保留。⚠️ **如实全记**:座上分不出是哪一只读法披露的(载荷不带读法),所以这一脸的每一发都计 —— 含已被拒的按键读与枚举(那些发本身是 fail-closed);抹除扫走无归属坏行那一形座上数不数得到未亲核。**出路 = core 把无归属行也改成拒,届时撤本 tag**(7.116.0 读不出能撤 ⇒ 照实留着)。计数非零 = 有会话的规则文件坏了:运维按探针里的 `sessionId` / `path` 去修(删文件即放弃那层规则,删前先看 `reason`)。认脸判据见 `durableAbsenceFaceOf`(披露路径落在本数据根的 `session-policy/` 之下);认不出的脸不计。7.114.0 合流时车 UY 曾以「core 已修」整只撤掉本 tag,修复轮恢复(那次删除未发版)。";
+    };
+    readonly "server.approval-crash-convergence.cause-unreadable": {
+        readonly cls: "F";
+        readonly note: "7.116.0 修复轮(`approval-crash-convergence.ts` 的 `convergeCrashedAsksAtBoot`;local 车道启动收敛):前世留下的一条 `STREAM_PENDING` 问行,它的卡信封(`card_json`)读不出 ⇒ 读不出 wire `approvalId`、无从向审计账要成因词 ⇒ 成因**回落**成 `crashed_before_park`。行照样收 VOID(决断口照样 410 —— 可决性 fail-closed,不受影响);最坏后果 = 一张其实是被有序关停截断的卡,在 410 体的 `deniedReason` 上说成「进程崩了」(`crashConverged` 读面若有它的审计组,那里的成因仍按审计账判,两处可能不同词)。计数非零 = 问账里有读不出卡信封的行(位腐 / 手改 / 版本错位),去看探针 detail 点名的 askId。读数另在启动日志 `approval_ask_audit_crash_converged` 的 `causeUnreadable` 格单列。";
     };
     readonly "server.outbound.connect-observer-threw": {
         readonly cls: "F";

package/dist/observability/fail-open.js

@@ -341,7 +341,11 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.session-policy.corrupt-read-fail-open": {
         cls: "P-DEBT",
-        note: "S-999(`observability/corrupt-read-seat.ts` 的 `createDurableAbsenceSeat`,`file_store_corrupt_read` 那只多脸座里认出的 **session-policy 脸**;local 车道,HTTP 服务的 local 腿与 run-local 同铸点):会话规则文件(数据根 `session-policy/` 下的行文件)坏了。core 7.39.2(#1299,本仓请托)起**按键读**(任务装规则、`GET` / `PUT /v1/sessions/:id/policy`)拒 —— `SessionPolicyError` 码 `corrupt`;但 core 包内 CHANGELOG 自陈另三张脸仍把坏行读成「无规则」:① `listBySession` 跳过坏行(会话同步导出读它 ⇒ 导出里没有这位 principal 的规则,目标端按无规则跑);② 别的会话的 `deleteBySession` 把撕尾行一并扫掉(常见形**不披露**),此后按键读得 ENOENT = 无规则;③ 数据根重绑把撕尾行留在旧键下。会话规则**只许收紧** ⇒ 丢的恰是调用方加的收紧(部署策略 / hooks / shell 门仍在)。方向 = fail-open,**明知不对**;SQL 孪生(`plugins/session-policy-store-sql.ts`)对同形响亮抛(CENSUS 第 81 行 P 终态)。归 P 类的理由是它决定权限门读到的规则层;归 DEBT 的理由是放行是 **core 的裁定**,源头修复纪律下本仓不包层,只让债在遥测里显形:计数逐次 + 探针行(`kind` / `path` / `sessionId` / `principal` / `reason`)+ 一次性 warn;逐命中 warn(`file_store_corrupt_read`)原样保留。⚠️ **如实全记**:座上分不出是哪一只读法披露的(载荷不带读法),所以这一脸的每一发都计 —— 含已被拒的按键读(那一发本身是 fail-closed);② 的常见形 core 不披露,座上**数不到**。**出路 = core 把三张脸也改成拒,届时撤本 tag**。计数非零 = 有会话的规则文件坏了:运维按探针里的 `sessionId` / `path` 去修(删文件即放弃那层规则,删前先看 `reason`)。认脸判据见 `durableAbsenceFaceOf`(披露路径落在本数据根的 `session-policy/` 之下);认不出的脸不计。7.114.0 合流时车 UY 曾以「core 已修」整只撤掉本 tag,修复轮恢复(那次删除未发版)。",
+        note: "S-999(`observability/corrupt-read-seat.ts` 的 `createDurableAbsenceSeat`,`file_store_corrupt_read` 那只多脸座里认出的 **session-policy 脸**;local 车道,HTTP 服务的 local 腿与 run-local 同铸点):会话规则文件(数据根 `session-policy/` 下的行文件)坏了。core 7.39.2(#1299,本仓请托)起**按键读**(任务装规则、`GET` / `PUT /v1/sessions/:id/policy`)拒 —— `SessionPolicyError` 码 `corrupt`;core 7.41.0(#1309)起另三张脸对**有归属**的坏行(行里的 `__sid`,否则同名高水位标记的 `__sid`)也收紧了:① 本会话的 `listBySession` 拒(`corrupt`;会话同步导出 `GET /v1/sessions/:id/sync/manifest` 转 500 `corrupt`);② 别的会话的 `deleteBySession` 不动它;③ 数据根重绑带走它(新键上按键读照拒)。**仍按「无规则」的只剩无归属的坏行**(行里读不出 `__sid`、同名高水位标记也不在;core 包内 CHANGELOG 逐字「keeps its old fate」):枚举略过并披露、它「根本不是 JSON」时被任一会话的抹除扫掉(此后按键读得 ENOENT = 无规则)、重绑留在旧键下 —— 钉 `test/corrupt-read-f-seats-s990.test.ts` 的 🚧「S-1016 残余」格。会话规则**只许收紧** ⇒ 丢的恰是调用方加的收紧(部署策略 / hooks / shell 门仍在)。方向 = fail-open,**明知不对**;SQL 孪生(`plugins/session-policy-store-sql.ts`)对同形响亮抛(CENSUS 第 81 行 P 终态)。归 P 类的理由是它决定权限门读到的规则层;归 DEBT 的理由是放行是 **core 的裁定**,源头修复纪律下本仓不包层,只让债在遥测里显形:计数逐次 + 探针行(`kind` / `path` / `sessionId` / `principal` / `reason`)+ 一次性 warn;逐命中 warn(`file_store_corrupt_read`)原样保留。⚠️ **如实全记**:座上分不出是哪一只读法披露的(载荷不带读法),所以这一脸的每一发都计 —— 含已被拒的按键读与枚举(那些发本身是 fail-closed);抹除扫走无归属坏行那一形座上数不数得到未亲核。**出路 = core 把无归属行也改成拒,届时撤本 tag**(7.116.0 读不出能撤 ⇒ 照实留着)。计数非零 = 有会话的规则文件坏了:运维按探针里的 `sessionId` / `path` 去修(删文件即放弃那层规则,删前先看 `reason`)。认脸判据见 `durableAbsenceFaceOf`(披露路径落在本数据根的 `session-policy/` 之下);认不出的脸不计。7.114.0 合流时车 UY 曾以「core 已修」整只撤掉本 tag,修复轮恢复(那次删除未发版)。",
+    },
+    "server.approval-crash-convergence.cause-unreadable": {
+        cls: "F",
+        note: "7.116.0 修复轮(`approval-crash-convergence.ts` 的 `convergeCrashedAsksAtBoot`;local 车道启动收敛):前世留下的一条 `STREAM_PENDING` 问行,它的卡信封(`card_json`)读不出 ⇒ 读不出 wire `approvalId`、无从向审计账要成因词 ⇒ 成因**回落**成 `crashed_before_park`。行照样收 VOID(决断口照样 410 —— 可决性 fail-closed,不受影响);最坏后果 = 一张其实是被有序关停截断的卡,在 410 体的 `deniedReason` 上说成「进程崩了」(`crashConverged` 读面若有它的审计组,那里的成因仍按审计账判,两处可能不同词)。计数非零 = 问账里有读不出卡信封的行(位腐 / 手改 / 版本错位),去看探针 detail 点名的 askId。读数另在启动日志 `approval_ask_audit_crash_converged` 的 `causeUnreadable` 格单列。",
     },
     "server.outbound.connect-observer-threw": {
         cls: "F",

package/dist/observability/permission-rule-events.d.ts

@@ -8,6 +8,9 @@ export declare const PERMISSION_RULE_EVENT_TABLE: readonly [{
 }, {
     readonly event: "read_only_allowed";
     readonly meaning: "the engine's read-only shell verdict cleared an ask that was NOT an operator-written rule (core decisionReason \"read_only\"; an operator-declared ask carries matchedAskRule and is never cleared this way)";
+}, {
+    readonly event: "skill_allowed";
+    readonly meaning: "an activated skill's allowed-tools list cleared the ask for the rest of that run (core decisionReason \"skill\"; today only a skill the request itself carried can do this — this deployment's own skills carry no lists; it clears only the unstated / ordinary questions a persisted allow rule may clear, never a deny / ask rule, an operator list, a governance or shell-floor question, or a mandated one)";
 }];
 /** 词表里的一个词(闭集)。 */
 export type PermissionRuleEventWord = (typeof PERMISSION_RULE_EVENT_TABLE)[number]["event"];

package/dist/observability/permission-rule-events.js

@@ -12,6 +12,10 @@ export const PERMISSION_RULE_EVENT_TABLE = [
         event: "read_only_allowed",
         meaning: "the engine's read-only shell verdict cleared an ask that was NOT an operator-written rule (core decisionReason \"read_only\"; an operator-declared ask carries matchedAskRule and is never cleared this way)",
     },
+    {
+        event: "skill_allowed",
+        meaning: "an activated skill's allowed-tools list cleared the ask for the rest of that run (core decisionReason \"skill\"; today only a skill the request itself carried can do this — this deployment's own skills carry no lists; it clears only the unstated / ordinary questions a persisted allow rule may clear, never a deny / ask rule, an operator list, a governance or shell-floor question, or a mandated one)",
+    },
 ];
 const PERMISSION_RULE_EVENT_KINDS = new Set(PERMISSION_RULE_EVENT_TABLE.map((r) => `${PERMISSION_TRACE_PREFIX}${r.event}`));
 export function isPermissionRuleEventKind(kind) {

package/dist/plugins/file-run-store.d.ts

@@ -182,7 +182,7 @@ export declare class FileRunStore {
     /** Release any claim whose row is now terminal; KEEP suspended/needs_review (resume re-finds them). One place for
      *  the claim-release invariant, shared by reapRunning + reclaimOrphanedAtBoot. */
     private sweepClaims;
-    /** Flip every `running` row matching `pred` → failed (with `reason`), then sweep terminal claims. */
+    /** Flip every `running` row matching `pred` → failed (with the death sentence `reason` + its machine `code`), then sweep terminal claims. */
     private reapRunning;
     reapStale(olderThanMs: number): Promise<number>;
     /** TOC integration ask③ (INTEGRATION-DESIGN §11): a host-lane engine restart leaves the PREVIOUS process's
@@ -320,6 +320,12 @@ export declare class FileRunStore {
      * @returns 被改写的账本**行**数(不是 run 数)。
      */
     migrateRetiredAskOriginRows(): Promise<number>;
+    /**
+     * 一次性迁移 **M6 的 local 腿**(窗、删法与删后谁接住:窗口见 `plugins/one-time-migrations.ts` 登记表):把 ≤7.115.x 写下的死亡判决行
+     * (`failed` ∧ 码列空 ∧ 句子是那两句,判据 = `readLegacyHolderDeathCode`)补上机读码,盘上(`run.json` 整份原子替换,同 `persist`)与内存同改。
+     * 起服时调(`LocalBackend.runOneTimeMigrations`,任何读者之前);数据根独占 ⇒ 本车道没有滚动升级窗,不需要读侧半场。幂等:第二跑零命中零写盘。
+     */
+    migrateLegacyHolderDeathCodes(): number;
     /** Release every open event-log fd (called by LocalBackend.close so a graceful restart can re-open the data dir). */
     dispose(): void;
 }

package/dist/plugins/file-run-store.js

@@ -7,7 +7,7 @@ import { randomBytes } from "node:crypto";
 import { AppendLog, atomicWriteFile, ensureDir, isProcessLive, processFingerprint, sanitizePathComponent, writeThenLink } from "@sema-agent/core";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { replayJsonlSkipping } from "../observability/corrupt-read-seat.js";
-import { RUN_ORPHANED_ERROR, RUN_STALLED_ERROR, StoreBootRefusalError, buildRunOrphanedError } from "./store-contracts.js";
+import { RUN_HOLDER_DEATH_CODES, RUN_ORPHANED_ERROR, RUN_STALLED_ERROR, StoreBootRefusalError, buildRunOrphanedError, readLegacyHolderDeathCode } from "./store-contracts.js";
 import { notifyRunTerminal } from "../observability/run-terminal.js";
 import { migrateRetiredAskOrigin } from "./one-time-migrations.js";
 const ownerEq = (a, b) => (a ?? null) === (b ?? null);
@@ -573,13 +573,14 @@ export class FileRunStore {
                 this.releaseClaim(sessionId);
         }
     }
-    reapRunning(pred, reason) {
+    reapRunning(pred, reason, code) {
         let reaped = 0;
         for (const r of this.runs.values()) {
             if (r.status === "running" && pred(r)) {
                 r.status = "failed";
                 r.result = null;
                 r.error = reason;
+                r.errorCode = code;
                 r.updatedAt = new Date();
                 this.persist(r);
                 reaped += 1;
@@ -590,7 +591,7 @@ export class FileRunStore {
     }
     async reapStale(olderThanMs) {
         const cutoff = Date.now() - olderThanMs;
-        return this.reapRunning((r) => r.updatedAt.getTime() < cutoff, RUN_STALLED_ERROR);
+        return this.reapRunning((r) => r.updatedAt.getTime() < cutoff, RUN_STALLED_ERROR, RUN_HOLDER_DEATH_CODES.stalled);
     }
     async reclaimOrphanedAtBoot(isResumable) {
         const orphans = [];
@@ -602,6 +603,7 @@ export class FileRunStore {
             r.status = "failed";
             r.result = null;
             r.error = RUN_ORPHANED_ERROR;
+            r.errorCode = RUN_HOLDER_DEATH_CODES.orphaned;
             r.updatedAt = new Date();
             this.persist(r);
         }
@@ -730,7 +732,7 @@ export class FileRunStore {
                 const verdict = await this.judgeClaim(sessionId, claim, holder);
                 if (verdict.kind === "live")
                     return { ok: false, activeTaskId: verdict.holderTaskId ?? holder };
-                this.takeOverClaim(sessionId, verdict.reason, verdict.snapshot);
+                this.takeOverClaim(sessionId, verdict.reason, verdict.snapshot, verdict.code);
             }
         }
         try {
@@ -806,9 +808,9 @@ export class FileRunStore {
             pidStillRunning: owner !== undefined && isProcessLive({ pid: owner.pid }),
             note: "the claim's owner process is provably not the one that wrote it (fingerprint falsified, or the pid is gone) and the row has nothing left to resume — taking the claim over",
         });
-        return { kind: "stale", reason: buildRunOrphanedError(who), snapshot };
+        return { kind: "stale", reason: buildRunOrphanedError(who), snapshot, code: RUN_HOLDER_DEATH_CODES.orphaned };
     }
-    takeOverClaim(sessionId, reason, snapshot) {
+    takeOverClaim(sessionId, reason, snapshot, code) {
         const nowClaim = readClaimRecord(singleRecordOf(this.readRecords(this.activePath(sessionId), CLAIM_RECORD_SHAPE)), sessionId);
         if (snapshot.torn) {
             if (nowClaim !== undefined)
@@ -820,7 +822,7 @@ export class FileRunStore {
         if (row?.status !== snapshot.status || row?.updatedAt.getTime() !== snapshot.updatedAtMs)
             return false;
         if (row && (row.status === "running" || row.status === "suspended" || row.status === "needs_review")) {
-            this.persist({ ...row, status: "failed", error: reason, updatedAt: new Date() });
+            this.persist({ ...row, status: "failed", error: reason, ...(code !== undefined ? { errorCode: code } : {}), updatedAt: new Date() });
         }
         const quarantine = join(this.tmpDir, `stale-claim.${sanitizePathComponent(sessionId)}.${process.pid}.${randomBytes(6).toString("hex")}`);
         try {
@@ -899,6 +901,17 @@ export class FileRunStore {
         }
         return migrated;
     }
+    migrateLegacyHolderDeathCodes() {
+        let migrated = 0;
+        for (const r of this.runs.values()) {
+            const code = readLegacyHolderDeathCode(r);
+            if (code === null || r.errorCode === code)
+                continue;
+            this.persist({ ...r, errorCode: code });
+            migrated += 1;
+        }
+        return migrated;
+    }
     dispose() {
         for (const log of this.eventLogs.values()) {
             try {

package/dist/plugins/memory-run-store.js

@@ -1,7 +1,7 @@
 import { redactErrorMessage, redactLedgerEventData, sealRunRowResult } from "../observability/run-terminal.js";
 import { outwardPlane } from "../terminal.js";
 import { projectUsageStats, USAGE_SCAN_LIMIT } from "../usage-analytics.js";
-import { RUN_STALLED_ERROR } from "./store-contracts.js";
+import { RUN_HOLDER_DEATH_CODES, RUN_STALLED_ERROR } from "./store-contracts.js";
 import { notifyRunTerminal } from "../observability/run-terminal.js";
 const ownerEq = (a, b) => (a ?? null) === (b ?? null);
 export class MemoryRunStore {
@@ -300,6 +300,7 @@ export class MemoryRunStore {
                 r.status = "failed";
                 r.result = null;
                 r.error = RUN_STALLED_ERROR;
+                r.errorCode = RUN_HOLDER_DEATH_CODES.stalled;
                 r.updatedAt = new Date();
                 reaped += 1;
             }

package/dist/plugins/one-time-migrations.d.ts

@@ -22,6 +22,8 @@ export interface OneTimeMigrationReport {
     readonly sessionIncarnationColumn: "added" | "present" | "no-table" | "lazy-on-read";
     /** M5:本次给空化身铸了令牌的行数。非零 = 这次迁移真写了存量行,必须让运维看见(与 M4 同一条纪律)。 */
     readonly sessionIncarnationsBackfilled: number;
+    /** M6:本次给「只有句子」的死亡判决行补上机读码的 run 行数(SQL `task_run` / local `run.json`)。非零 = 这次迁移真写了存量行(与 M4 同一条纪律)。 */
+    readonly holderDeathCodeRowsBackfilled: number;
 }
 /**
  * S-590 —— 一条一次性迁移的窗(登记表的一行;纯数据)。字段注写着每个值的取证方式,改一行之前照着重核。
@@ -54,8 +56,8 @@ export interface OneTimeMigrationWindow {
  * 而留着 M3 会让 M3 永远判「跑过了」。三条同版引入、同一天到期,本来就同一次删。
  */
 export declare const ONE_TIME_MIGRATIONS: readonly OneTimeMigrationWindow[];
-/** local 车道上 SQL 独有的四条(M1 / M2 / M4 / M5)的读数:那几张表 / 列在文件底座上从来不存在 ⇒ 如实答 absent / 0。 */
-export declare const NO_SQL_MIGRATIONS: Omit<OneTimeMigrationReport, "askOriginRowsMigrated">;
+/** local 车道上 SQL 独有的四条(M1 / M2 / M4 / M5)的读数(M3 / M6 两车道都有,local 腿的读数由 `LocalBackend.runOneTimeMigrations` 现算):那几张表 / 列在文件底座上从来不存在 ⇒ 如实答 absent / 0。 */
+export declare const NO_SQL_MIGRATIONS: Omit<OneTimeMigrationReport, "askOriginRowsMigrated" | "holderDeathCodeRowsBackfilled">;
 /** 启动期的日志口(logger 的子集)。两级各有其用,见 {@link logOneTimeMigrations}。 */
 export interface MigrationLogSink {
     warn(msg: string, meta?: Record<string, unknown>): void;

package/dist/plugins/one-time-migrations.js

@@ -2,6 +2,7 @@ import { acquireEnsureSchemaLock, releaseEnsureSchemaLock } from "./tidb-pool.js
 import { acquirePgEnsureSchemaLock, releasePgEnsureSchemaLock } from "./pg-pool.js";
 import { jsonColumnTextExpr } from "./sql-json-column.js";
 import { SESSION_META_INCARNATION_COLUMN, mintSessionIncarnation } from "../session-incarnation.js";
+import { RUN_HOLDER_DEATH_CODES, RUN_ORPHANED_ERROR, RUN_STALLED_ERROR } from "./store-contracts.js";
 export const ONE_TIME_MIGRATIONS = [
     {
         id: "M1",
@@ -62,6 +63,19 @@ export const ONE_TIME_MIGRATIONS = [
             "`session.incarnation_missing`(parked 决定腿因此拒、记忆座退回按 id 绑定并 warn)—— 运维手工给那些行填一只随机令牌即可",
         reportKeys: ["sessionIncarnationColumn", "sessionIncarnationsBackfilled"],
     },
+    {
+        id: "M6",
+        introducedIn: "7.116.0",
+        releasedOn: "2026-10-05",
+        removableAfter: "2026-11-04",
+        removal: "删 migrateOn 的 M6 步(`task_run` 两条 `UPDATE … SET error_code`)与 local 腿 `FileRunStore.migrateLegacyHolderDeathCodes`(及 " +
+            "`LocalBackend.runOneTimeMigrations` 里那一格);报告与日志行的 `holderDeathCodeRowsBackfilled`;**连同读侧半场一起删**:" +
+            "`store-contracts.ts` 的 `readLegacyHolderDeathCode` 与 SQL 行映射 `run-store-sql.ts#rowToRun` 里对它的调用(码列改回原样读)",
+        afterRemoval: "没有响亮臂:窗关删码之后仍只有句子、码列为空的行(跳过了所有带 M6 的版本直接升的库,或窗关之后还在写的 ≤7.115.x 副本)不再被判成持有者死亡 —— " +
+            "用户输入受理账本的收敛判词(`user-input-ledger.ts` `judgeOpen`)对这种行落到「其余」臂 `leg_over`:补落 `settled{leg_end}`、不告知,那条 run 上" +
+            "丢掉的 steer 不再告诉用户;`GET /v1/runs/:id` 上 `errorCode` 缺席、只剩 `error` 句子",
+        reportKeys: ["holderDeathCodeRowsBackfilled"],
+    },
 ];
 export const NO_SQL_MIGRATIONS = {
     retiredSnapshotTable: "absent",
@@ -204,6 +218,12 @@ async function migrateOn(db, dialect) {
         : await db.exec(`UPDATE ${AUDIT_TABLE} SET ${AUDIT_DETAIL_COLUMN} = NULL ` +
             `WHERE ${AUDIT_DETAIL_COLUMN} IS NOT NULL AND ${jsonColumnTextExpr(dialect, AUDIT_DETAIL_COLUMN)} = 'null'`);
     const { sessionIncarnationColumn, sessionIncarnationsBackfilled } = await migrateSessionIncarnations(db, dialect);
+    const holderDeathCodeRowsBackfilled = (await db.exec(dialect === "tidb"
+        ? "UPDATE task_run SET error_code = ? WHERE status = 'failed' AND error_code IS NULL AND error = ?"
+        : "UPDATE task_run SET error_code = $1 WHERE status = 'failed' AND error_code IS NULL AND error = $2", [RUN_HOLDER_DEATH_CODES.stalled, RUN_STALLED_ERROR])) +
+        (await db.exec(dialect === "tidb"
+            ? "UPDATE task_run SET error_code = ? WHERE status = 'failed' AND error_code IS NULL AND (error = ? OR error LIKE ?)"
+            : "UPDATE task_run SET error_code = $1 WHERE status = 'failed' AND error_code IS NULL AND (error = $2 OR error LIKE $3)", [RUN_HOLDER_DEATH_CODES.orphaned, RUN_ORPHANED_ERROR, `${RUN_ORPHANED_ERROR} (%`]));
     let retiredSnapshotTable = "absent";
     let retiredSnapshotRows = 0;
     let retiredSteerSeatColumn = "absent";
@@ -236,7 +256,7 @@ async function migrateOn(db, dialect) {
     }
     return {
         retiredSnapshotTable, retiredSnapshotRows, retiredSteerSeatColumn, retiredSteerSeatStaleRows, askOriginRowsMigrated, auditDetailJsonNullRows,
-        sessionIncarnationColumn, sessionIncarnationsBackfilled,
+        sessionIncarnationColumn, sessionIncarnationsBackfilled, holderDeathCodeRowsBackfilled,
     };
 }
 const INCARNATION_BACKFILL_BATCH = 500;
@@ -309,7 +329,7 @@ export function migrateRetiredAskOrigin(type, data) {
 }
 export function logOneTimeMigrations(log, backend, report) {
     const changed = report.retiredSnapshotTable === "dropped" || report.retiredSteerSeatColumn === "dropped" || report.askOriginRowsMigrated > 0 || report.auditDetailJsonNullRows > 0 ||
-        report.sessionIncarnationColumn === "added" || report.sessionIncarnationsBackfilled > 0;
+        report.sessionIncarnationColumn === "added" || report.sessionIncarnationsBackfilled > 0 || report.holderDeathCodeRowsBackfilled > 0;
     (changed ? log.warn : log.info).call(log, "one_time_migrations_applied", {
         backend,
         retiredSnapshotTable: report.retiredSnapshotTable,
@@ -320,11 +340,14 @@ export function logOneTimeMigrations(log, backend, report) {
         auditDetailJsonNullRows: report.auditDetailJsonNullRows,
         sessionIncarnationColumn: report.sessionIncarnationColumn,
         sessionIncarnationsBackfilled: report.sessionIncarnationsBackfilled,
+        holderDeathCodeRowsBackfilled: report.holderDeathCodeRowsBackfilled,
         removableAfter: Object.fromEntries(ONE_TIME_MIGRATIONS.map((w) => [w.id, w.removableAfter])),
         note: "one-time persisted-data migrations (M1: retired whole-tree snapshot index table dropped; M2: retired single-seat " +
             "steering column dropped; M3: retired ask-origin spelling rewritten in place; M4: audit details written as the JSON " +
             "text `null` by an earlier version folded to a SQL NULL, so \"no detail\" has exactly one on-disk spelling; M5: the " +
-            "session incarnation column added and every session row without one minted its own token). Each step " +
+            "session incarnation column added and every session row without one minted its own token; M6: run rows failed by a " +
+            "holder-death verdict written by an earlier version with only the sentence got the machine-readable code run.stalled / " +
+            "run.orphaned). Each step " +
             "runs on every boot until its window closes (the release that introduced it + 30 days; the per-step date is in " +
             "removableAfter, null while that release is not published yet) and is deleted in the first minor after that — start a " +
             "version that still carries a step at least once before upgrading past its deletion.",

package/dist/plugins/pg-session-storage.js

@@ -317,7 +317,7 @@ export class PgSessionStore {
             return `$${params.length}`;
         };
         const where = ["sm.placement_kind IS NULL"];
-        if (opts.owner)
+        if (opts.owner !== undefined)
             where.push(opts.includeUnowned ? `(sm.owner = ${ph(opts.owner)} OR sm.owner IS NULL)` : `sm.owner = ${ph(opts.owner)}`);
         if (opts.q)
             where.push(`EXISTS (SELECT 1 FROM task_run tr WHERE tr.session_id = sm.session_id AND LOWER(tr.objective_preview) LIKE LOWER(${ph(`%${escapeLike(opts.q)}%`)}) ESCAPE '\\')`);

package/dist/plugins/run-store-sql.js

@@ -6,7 +6,7 @@ import { pgSanitizeText } from "./pg-safe-json.js";
 import { toIso as iso } from "./sql-row-helpers.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { createObjectColumnReader, decodeJsonColumn, decodeNullableJsonColumn, foldJsonColumn, isJsonColumnBodyProblem, jsonColumnText, readJsonObjectColumn, readNonNullJsonValueColumn } from "./sql-json-column.js";
-import { RUN_STALLED_ERROR } from "./store-contracts.js";
+import { RUN_HOLDER_DEATH_CODES, RUN_STALLED_ERROR, readLegacyHolderDeathCode } from "./store-contracts.js";
 import { notifyRunTerminal, runTerminalLogLevel } from "../observability/run-terminal.js";
 import { mysqlDriver, pgDriver, dialectJsonEncoder } from "./sql-driver.js";
 import { isDupKeyError } from "./sql-errors.js";
@@ -214,7 +214,7 @@ export class SqlRunStore {
             status: r.status,
             result: refusing("serve a finished run as if it had produced nothing", () => decodeResultColumn(r.result, String(r.task_id))) ?? null,
             error: r.error ?? null,
-            errorCode: r.error_code ?? null,
+            errorCode: readLegacyHolderDeathCode({ status: String(r.status), error: r.error ?? null, errorCode: r.error_code ?? null }),
             jobId: r.job_id ?? null,
             source: r.source ?? null,
             instanceId: r.instance_id ?? null,
@@ -424,8 +424,8 @@ export class SqlRunStore {
         const cutoff = new Date(Date.now() - olderThanMs);
         let reaped = 0;
         await this.tx(async (conn) => {
-            const { affected } = await conn.query(this.q(`UPDATE task_run SET status = 'failed', result = NULL, error = '${RUN_STALLED_ERROR}', updated_at = ? ` +
-                "WHERE status = 'running' AND updated_at < ?", `UPDATE task_run SET status = 'failed', result = NULL, error = '${RUN_STALLED_ERROR}', updated_at = $1 ` +
+            const { affected } = await conn.query(this.q(`UPDATE task_run SET status = 'failed', result = NULL, error = '${RUN_STALLED_ERROR}', error_code = '${RUN_HOLDER_DEATH_CODES.stalled}', updated_at = ? ` +
+                "WHERE status = 'running' AND updated_at < ?", `UPDATE task_run SET status = 'failed', result = NULL, error = '${RUN_STALLED_ERROR}', error_code = '${RUN_HOLDER_DEATH_CODES.stalled}', updated_at = $1 ` +
                 "WHERE status = 'running' AND updated_at < $2"), [new Date(), cutoff]);
             reaped = affected;
             await conn.query(this.q("DELETE ta FROM task_active ta JOIN task_run tr ON ta.task_id = tr.task_id WHERE tr.status NOT IN ('running','suspended','needs_review')", "DELETE FROM task_active ta USING task_run tr WHERE ta.task_id = tr.task_id AND tr.status NOT IN ('running','suspended','needs_review')"));