@sema-agent/server 7.93.5 → 7.93.7

package/dist/plugins/host-platform.d.ts

@@ -1,3 +1,28 @@
+/**
+ * Host-lane PLATFORM seam (DESIGN-windows-native.md, FINAL r3) — the ONE place the host exec adapter's
+ * POSIX/win32 differences live, so `remote-env-host.ts` stays a single code path with platform-gated leaves.
+ *
+ * 🔴 Iron invariant (design §4.1): the POSIX path is BYTE-IDENTICAL to the pre-Windows code — every helper is
+ * `win32 ? new : exactly-what-the-inline-code-did` (same syscall, same throw behavior). Never "improve" POSIX
+ * here; the existing full test suite is the regression net.
+ *
+ * win32 semantics (design D1-D4):
+ *  - shell   = Git Bash via core 1.224 `getShellConfig` (WSL-launcher-filtered — the `System32\bash.exe`
+ *              trap). Fail-LOUD when absent; never silently degrade to cmd (D1).
+ *  - kill    = core 1.224 `signalProcessTree` (taskkill /T, /F for hard). Soft is a no-op for console trees
+ *              (taskkill errors "can only be terminated forcefully") — the SIGTERM→grace→SIGKILL ladder is
+ *              effectively delay→hard-kill on win32; accepted, CC-identical (D2).
+ *  - spawn   = `detached:false` + `windowsHide:true` (no console window; no POSIX process group — the kill
+ *              side uses the tree, not the group) (D3).
+ *  - env     = case-insensitive key collapse before spawn (win32 env keys are case-insensitive; a `Path`+`PATH`
+ *              pair from case-sensitive Object.assign reaches CreateProcess as ONE undefined-which
+ *              entry). Canonical casing = the first-seen key (process.env's native casing wins since the
+ *              inherit base is spread first).
+ *
+ * ⚠️ The win32 branches are UNVERIFIED on a real machine until S5 (Windows CI runner) — design D5 discipline:
+ * structural tests only on mac/Linux; behavior-level bite happens on the first Windows-runner green.
+ */
+import type { ChildProcess } from "node:child_process";
 import { killProcessTree } from "@sema-agent/core";
 export declare const IS_WIN32: boolean;
 export interface HostShell {
@@ -48,15 +73,52 @@ export declare function killTreeSoft(pid: number): void;
 /** Graceful tree kill where the CALLER has no escalation timer of its own (currently unused by the host lane —
  *  exported for parity with core's surface; the bg driver keeps its own HOST_BG_KILL_GRACE_MS ladder). */
 export { killProcessTree };
-/** 登记回执 = 注销的唯一凭据(纯数据;身份即凭据,见簿注)。 */
+/**
+ * 登记回执 = 注销的**唯一**凭据(身份即凭据,见簿注)+ 一只幂等的注销把手。
+ *
+ * S-566 归一轮:注销**只有这一张脸**(`release()`)。此前另有一只 `untrackHostForegroundChild(ticket)`
+ * 自由函数,于是「把这只回执从簿上删掉」有两种写法 —— 零别名纪律下这属于歧义面,已**整个删除**
+ * (硬 breaking 三句:没有别名、没有过渡方法,调用方的 tsc 红就是通知)。
+ */
 export interface ForegroundChildTicket {
     /** 组领袖 pid = pgid(POSIX `detached:true` 的直接后果)。 */
     readonly pid: number;
+    /**
+     * 提前注销 —— 给各腿**特有**的兜底时点用(settle / `close` / 领养移交 / 生成器 `finally`)。
+     * 幂等(同一只回执 release 多少次都一样),且按**身份**删 ⇒ 迟到的那一次**绝不**碰内核复用同号之后
+     * 的新登记。主时点(`exit` / `error`)由 {@link adoptHostForegroundChild} 自己挂,调用点不必重复写。
+     */
+    release(): void;
 }
-/** 登记一只自起的前台子进程,返回注销用的回执。 */
+/**
+ * 登记一只自起的前台子进程(**低层原语**:只有 pid 在手时用它 —— 产品码一律走
+ * {@link adoptHostForegroundChild},见那条形状钉)。
+ */
 export declare function trackHostForegroundChild(pid: number): ForegroundChildTicket;
-/** 注销(`exit` / settle / 领养移交)。按回执身份删 ⇒ 幂等,且**绝不**碰同号的其它登记。 */
-export declare function untrackHostForegroundChild(ticket: ForegroundChildTicket): void;
+/**
+ * 🔴 **本簿在 `src/` 的唯一登记口**(S-566 归一轮)—— 一只自起的 detached 前台子进程「进簿 + 两只主注销」
+ * 的**全部**语义收在这里。
+ *
+ * ── 为什么是一只函数而不是五处同一句 ────────────────────────────────────────────────────────────
+ * 归一前,这一句在仓里**手抄五份**(`remote-env-host.ts` 三条 fg 腿 + `hook-runner.ts` 两条):
+ * 「`pid != null` 才登记」「`exit` 主注销」「`error` 之后 `exit` 可能不来,所以也要注销」——
+ * 每多一条 detached 腿就要再抄一遍,而**第六处只要漏抄一臂就是一个静默的孤儿洞**(S-566 的病正是
+ * hook 那两条腿整份没抄)。一条规则答完所有腿,规则集因此变小而不是变大。
+ *
+ * ── 语义(三条,逐条有理由)────────────────────────────────────────────────────────────────────
+ *  · **无 pid ⇒ `undefined`,不登记**:spawn 起手失败那一族根本没有组领袖,簿上放一个 `undefined` 的坐标
+ *    等于给收割腿一条假线索;调用点因此拿到的是一个「可能不在」的把手,漏判会被类型挡住。
+ *  · **`exit` = 主注销时点**(不是 `close` / settle):`close` 是**管道**驱动的,一个继承了 stdout 的孙进程
+ *    能把它按住任意久;而一条已退的 pid 留在簿里 = 给收割腿一个**过期坐标** —— 内核复用那个号之后
+ *    `kill(-pid)` 打的是**别人**的组。
+ *  · **`error` 也注销**:Node 契约里 `error` 之后 `exit` **可能不来**(异步起手失败),那一形没有第二次机会。
+ *    本函数只挂注销,**不**吞 `error` —— 五条腿各自的 `error` 处置(记账 / settle / 铸故障帧)原样在位,
+ *    本监听是第 N 只监听器,不改变「`error` 有没有人接」这件事(亲核:五处在归一前就都已有 `error` 监听)。
+ *
+ * 各腿**特有**的兜底(settle / `close` / 领养移交 / 生成器 `finally`)留在调用点,写成一行
+ * `ticket?.release()` —— 它们是**那条腿自己的**生命周期事实,不是本簿的语义。
+ */
+export declare function adoptHostForegroundChild(child: ChildProcess): ForegroundChildTicket | undefined;
 /** 一次前台收割的读数。三格分开是**刻意**的:`alreadyDead` 是想要的结果(不是失败),`failed` 是**真的**
  *  没收上来 —— 两者混成一个数就等于把后者静默掉([ref]:这条腿上不许有安静的兜底)。
  *

package/dist/plugins/host-platform.js

@@ -56,12 +56,23 @@ export function killTreeSoft(pid) {
 export { killProcessTree };
 const liveHostForegroundGroups = new Set();
 export function trackHostForegroundChild(pid) {
-    const ticket = { pid };
+    const ticket = {
+        pid,
+        release() {
+            liveHostForegroundGroups.delete(ticket);
+        },
+    };
     liveHostForegroundGroups.add(ticket);
     return ticket;
 }
-export function untrackHostForegroundChild(ticket) {
-    liveHostForegroundGroups.delete(ticket);
+export function adoptHostForegroundChild(child) {
+    const pid = child.pid;
+    if (pid == null)
+        return undefined;
+    const ticket = trackHostForegroundChild(pid);
+    child.once("exit", () => ticket.release());
+    child.once("error", () => ticket.release());
+    return ticket;
 }
 export function reapHostForegroundChildren() {
     let signalled = 0;

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

@@ -2,7 +2,7 @@ import { uuidv7 } from "@sema-agent/core";
 import { createHash } from "node:crypto";
 import { isDupKeyError } from "./sql-errors.js";
 import { mysqlDriver, pgDriver, dialectJsonEncoder } from "./sql-driver.js";
-import { parseJsonOr } from "./sql-row-helpers.js";
+import { decodeNullableJsonColumn, foldJsonColumn, jsonColumnText, readNonNullJsonValueColumn } from "./sql-json-column.js";
 import { ensureIndexes } from "./ensure-index.js";
 export const LEADER_RUN_TABLE = "leader_run";
 const LEADER_RUN_STATUSES = new Set(["running", "completed", "failed", "needs_human"]);
@@ -59,7 +59,17 @@ export async function ensurePgLeaderRunSchema(q) {
 }
 export const STALE_SWEEP_REASON = "leader run went stale: no replica settled it within LEADER_RUN_STALE_MS (the replica driving it most likely died). " +
     "The run was NOT taken over — re-submit with a NEW Idempotency-Key to run it again.";
-const SELECT_COLS = "leader_run_id, owner, objective_preview, status, result, error, started_at_ms, finished_at_ms";
+function selectCols(dialect) {
+    return `leader_run_id, owner, objective_preview, status, ${jsonColumnText(dialect, "result")}, error, started_at_ms, finished_at_ms`;
+}
+function readResultColumn(text, id) {
+    try {
+        return decodeNullableJsonColumn(text, readNonNullJsonValueColumn, `${LEADER_RUN_TABLE}.result for leader run ${id}`);
+    }
+    catch (e) {
+        throw foldJsonColumn(e, (m) => new Error(`leader_run: ${m} — refusing rather than serve this run as if it had finished empty-handed`));
+    }
+}
 function statusOf(raw, id) {
     const s = String(raw);
     if (!LEADER_RUN_STATUSES.has(s)) {
@@ -69,7 +79,7 @@ function statusOf(raw, id) {
 }
 function mapRow(r) {
     const id = String(r.leader_run_id);
-    const result = r.result == null ? undefined : parseJsonOr(r.result, undefined);
+    const result = readResultColumn(r.result, id);
     const error = r.error == null ? undefined : String(r.error);
     const finished = r.finished_at_ms == null ? undefined : Number(r.finished_at_ms);
     return {
@@ -113,12 +123,12 @@ export class SqlLeaderRunStore {
         return { created: true, run };
     }
     async getRun(id) {
-        const res = await this.db.query(this.q(`SELECT ${SELECT_COLS} FROM ${LEADER_RUN_TABLE} WHERE leader_run_id = ?`, `SELECT ${SELECT_COLS} FROM ${LEADER_RUN_TABLE} WHERE leader_run_id = $1`), [id]);
+        const res = await this.db.query(this.q(`SELECT ${selectCols("tidb")} FROM ${LEADER_RUN_TABLE} WHERE leader_run_id = ?`, `SELECT ${selectCols("pg")} FROM ${LEADER_RUN_TABLE} WHERE leader_run_id = $1`), [id]);
         const row = res.rows[0];
         return row ? mapRow(row) : undefined;
     }
     async getByIdem(idemKey) {
-        const res = await this.db.query(this.q(`SELECT ${SELECT_COLS} FROM ${LEADER_RUN_TABLE} WHERE idem_key = ?`, `SELECT ${SELECT_COLS} FROM ${LEADER_RUN_TABLE} WHERE idem_key = $1`), [idemKey]);
+        const res = await this.db.query(this.q(`SELECT ${selectCols("tidb")} FROM ${LEADER_RUN_TABLE} WHERE idem_key = ?`, `SELECT ${selectCols("pg")} FROM ${LEADER_RUN_TABLE} WHERE idem_key = $1`), [idemKey]);
         const row = res.rows[0];
         return row ? mapRow(row) : undefined;
     }
@@ -132,7 +142,7 @@ export class SqlLeaderRunStore {
     }
     async finishRun(id, patch) {
         const json = dialectJsonEncoder(this.db.dialect);
-        const res = await this.db.query(this.q(`UPDATE ${LEADER_RUN_TABLE} SET status = ?, result = CAST(? AS JSON), error = ?, finished_at_ms = ? WHERE leader_run_id = ? AND status = 'running'`, `UPDATE ${LEADER_RUN_TABLE} SET status = $1, result = $2::jsonb, error = $3, finished_at_ms = $4 WHERE leader_run_id = $5 AND status = 'running'`), [patch.status, patch.result === undefined ? null : json(patch.result), patch.error ?? null, Date.now(), id]);
+        const res = await this.db.query(this.q(`UPDATE ${LEADER_RUN_TABLE} SET status = ?, result = CAST(? AS JSON), error = ?, finished_at_ms = ? WHERE leader_run_id = ? AND status = 'running'`, `UPDATE ${LEADER_RUN_TABLE} SET status = $1, result = $2::jsonb, error = $3, finished_at_ms = $4 WHERE leader_run_id = $5 AND status = 'running'`), [patch.status, patch.result == null ? null : json(patch.result), patch.error ?? null, Date.now(), id]);
         return res.affected > 0;
     }
 }

package/dist/plugins/remote-env-host.js

@@ -7,7 +7,7 @@ import { openSync, closeSync, readSync, statSync, truncateSync, unlinkSync, mkdi
 import { StringDecoder } from "node:string_decoder";
 import { armPipeDestroyGrace, numEnvOr, SYMLINK_CHAIN_MAX_HOPS } from "./remote-shell.js";
 import { hostBackgroundShellEnabled, hostExecSpoolEnabled } from "../config.js";
-import { resolveHostShell, hostShell, spawnGroupOptions, killTreeHard, killTreeSoft, collapseWin32EnvKeys, trackHostForegroundChild, untrackHostForegroundChild } from "./host-platform.js";
+import { resolveHostShell, hostShell, spawnGroupOptions, killTreeHard, killTreeSoft, collapseWin32EnvKeys, adoptHostForegroundChild } from "./host-platform.js";
 import { BackgroundShellManager, seedMemStream, feedMemStream, drainMemStream } from "./background-shell-support.js";
 import { FileError, ExecutionError, RemoteExecutionError, scrubSecretEnv, RollingTailBuffer, markTruncated, SchedulerError, BackgroundShellError, } from "@sema-agent/core";
 import { recordSecretEnvScrub } from "../observability/secret-env-scrub.js";
@@ -403,15 +403,12 @@ export class RemoteHostExecutionEnv {
                 env: this.mergeEnv(options?.env),
                 ...spawnGroupOptions(),
             });
-            const ticket = child.pid != null ? trackHostForegroundChild(child.pid) : undefined;
-            if (ticket)
-                child.once("exit", () => untrackHostForegroundChild(ticket));
+            const ticket = adoptHostForegroundChild(child);
             const finish = (r) => {
                 if (settled)
                     return;
                 settled = true;
-                if (ticket)
-                    untrackHostForegroundChild(ticket);
+                ticket?.release();
                 clearTimeout(timer);
                 options?.abortSignal?.removeEventListener("abort", onAbort);
                 removeDetachListener?.();
@@ -460,8 +457,7 @@ export class RemoteHostExecutionEnv {
                 if (forceSettleTimer)
                     clearTimeout(forceSettleTimer);
                 options?.abortSignal?.removeEventListener("abort", onAbort);
-                if (ticket)
-                    untrackHostForegroundChild(ticket);
+                ticket?.release();
                 settled = true;
                 resolve(ok({ stdout: seedOut, stderr: seedErr, exitCode: 0, detached: { shellId } }));
             };
@@ -621,8 +617,7 @@ export class RemoteHostExecutionEnv {
                     clearInterval(pump);
                     pump = undefined;
                 }
-                if (ticket)
-                    untrackHostForegroundChild(ticket);
+                ticket?.release();
                 if (drainTimer) {
                     clearTimeout(drainTimer);
                     drainTimer = undefined;
@@ -675,8 +670,7 @@ export class RemoteHostExecutionEnv {
                 cleanupSpool();
                 throw e;
             }
-            if (child.pid != null)
-                ticket = trackHostForegroundChild(child.pid);
+            ticket = adoptHostForegroundChild(child);
             closeSpoolFds();
             child.on("error", (e) => {
                 finish({ ok: false, error: new ExecutionError("spawn_error", `host spawn failed: ${e.message}`) });
@@ -765,8 +759,6 @@ export class RemoteHostExecutionEnv {
                 settleFromTermination(code, signal);
             });
             child.on("exit", (code, signal) => {
-                if (ticket)
-                    untrackHostForegroundChild(ticket);
                 exited = true;
                 drainTimer = setTimeout(() => settleFromTermination(code, signal), EXIT_SETTLE_DRAIN_MS);
                 drainTimer.unref?.();
@@ -811,9 +803,7 @@ export class RemoteHostExecutionEnv {
         const signalReady = () => { const w = wake; wake = undefined; w?.(); };
         const sh = hostShell();
         const child = spawn(sh.shell, [...sh.args, command], { cwd, env: this.mergeEnv(options?.env), ...spawnGroupOptions() });
-        const ticket = child.pid != null ? trackHostForegroundChild(child.pid) : undefined;
-        if (ticket)
-            child.once("exit", () => untrackHostForegroundChild(ticket));
+        const ticket = adoptHostForegroundChild(child);
         let pipeDestroyTimer;
         const kill = () => {
             try {
@@ -848,8 +838,7 @@ export class RemoteHostExecutionEnv {
         child.on("close", (code, signal) => {
             if (pipeDestroyTimer)
                 clearTimeout(pipeDestroyTimer);
-            if (ticket)
-                untrackHostForegroundChild(ticket);
+            ticket?.release();
             if (finished)
                 return;
             exitCode = code ?? (signal ? 128 + (signalNumber(signal) ?? 0) : 1);
@@ -925,8 +914,7 @@ export class RemoteHostExecutionEnv {
             if (wallTimer)
                 clearTimeout(wallTimer);
             options?.signal?.removeEventListener("abort", onAbort);
-            if (ticket)
-                untrackHostForegroundChild(ticket);
+            ticket?.release();
         }
     }
     async absolutePath(p) {

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

@@ -124,7 +124,7 @@ export declare class SqlRunStore {
     getActiveTaskId(sessionId: string): Promise<string | undefined>;
     /** Shared row→record mapper — byte-identical between dialects (both drivers hand back the same column
      *  names + comparable JS types after SqlDriver's result normalization).
-     *  🔴 **读它的每一条查询都必须选 {@link RUN_ROW_COLS}**(S-230):映射器对「没被 SELECT 的列」是
+     *  🔴 **读它的每一条查询都必须选 {@link runRowCols}**(S-230):映射器对「没被 SELECT 的列」是
      *  结构性失明的 —— `undefined ?? null` 与 `Boolean(undefined)` 都会安静地铸出一个**看上去合法的假值**。
      *  修前 `listRuns` 的两条方言臂就漏选 `instance_id`,于是列表面的每一行 `instanceId` 恒 `null`
      *  (今天没有消费点,所以没人发现)。列表收成一个常量 = 这类漏选从此不可能发生。 */

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

@@ -3,11 +3,42 @@ import { outwardPlane } from "../terminal.js";
 import { projectUsageStats, USAGE_SCAN_LIMIT } from "../usage-analytics.js";
 import { escapeLike } from "./sql-escape.js";
 import { pgSanitizeText } from "./pg-safe-json.js";
-import { parseJsonLenient as parseJson, toIso as iso } from "./sql-row-helpers.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 { notifyRunTerminal, runTerminalLogLevel } from "../observability/run-terminal.js";
 import { mysqlDriver, pgDriver, dialectJsonEncoder } from "./sql-driver.js";
 import { isDupKeyError } from "./sql-errors.js";
-const RUN_ROW_COLS = "task_id, session_id, owner, status, result, error, error_code, job_id, source, instance_id, cancel_requested, objective_preview, created_at, updated_at";
+function runRowCols(dialect) {
+    return (`task_id, session_id, owner, status, ${jsonColumnText(dialect, "result")}, error, error_code, job_id, source, ` +
+        "instance_id, cancel_requested, objective_preview, created_at, updated_at");
+}
+const readPersistedTaskResultBody = createObjectColumnReader();
+function decodeResultColumn(v, taskId) {
+    return decodeNullableJsonColumn(v, readPersistedTaskResultBody, `task_run.result for run ${taskId}`);
+}
+function refusing(what, read) {
+    try {
+        return read();
+    }
+    catch (e) {
+        throw foldJsonColumn(e, (m) => new Error(`SqlRunStore: ${m} — refusing rather than ${what}`));
+    }
+}
+function usageResultBody(v) {
+    try {
+        return decodeJsonColumn(v, readJsonObjectColumn, "task_run.result (usage scan row)");
+    }
+    catch (e) {
+        if (!isJsonColumnBodyProblem(e))
+            throw e;
+        recordFailOpen("server.sql-json.task-run.usage-result-unreadable");
+        return undefined;
+    }
+}
+function decodeEventDataColumn(v, taskId, seq) {
+    return decodeNullableJsonColumn(v, readNonNullJsonValueColumn, `task_event.data for run ${taskId} seq ${seq}`);
+}
 export class SqlRunStore {
     db;
     constructor(db) {
@@ -178,7 +209,7 @@ export class SqlRunStore {
             sessionId: String(r.session_id),
             owner: r.owner ?? null,
             status: r.status,
-            result: parseJson(r.result),
+            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,
             jobId: r.job_id ?? null,
@@ -191,7 +222,7 @@ export class SqlRunStore {
         };
     }
     async getRun(taskId) {
-        const { rows } = await this.db.query(this.q(`SELECT ${RUN_ROW_COLS} FROM task_run WHERE task_id = ?`, `SELECT ${RUN_ROW_COLS} FROM task_run WHERE task_id = $1`), [taskId]);
+        const { rows } = await this.db.query(this.q(`SELECT ${runRowCols("tidb")} FROM task_run WHERE task_id = ?`, `SELECT ${runRowCols("pg")} FROM task_run WHERE task_id = $1`), [taskId]);
         return rows[0] ? this.rowToRun(rows[0]) : undefined;
     }
     async listRuns(opts) {
@@ -220,7 +251,7 @@ export class SqlRunStore {
                 where.push("(created_at < ? OR (created_at = ? AND task_id < ?))");
                 params.push(new Date(opts.cursor.createdAt), new Date(opts.cursor.createdAt), opts.cursor.taskId);
             }
-            const sql = `SELECT ${RUN_ROW_COLS} FROM task_run` +
+            const sql = `SELECT ${runRowCols("tidb")} FROM task_run` +
                 (where.length ? " WHERE " + where.join(" AND ") : "") +
                 " ORDER BY created_at DESC, task_id DESC LIMIT ?";
             params.push(opts.limit);
@@ -247,7 +278,7 @@ export class SqlRunStore {
             const t = p(opts.cursor.taskId);
             where.push(`(created_at < ${a} OR (created_at = ${b} AND task_id < ${t}))`);
         }
-        const sql = `SELECT ${RUN_ROW_COLS} FROM task_run` +
+        const sql = `SELECT ${runRowCols("pg")} FROM task_run` +
             (where.length ? " WHERE " + where.join(" AND ") : "") +
             ` ORDER BY created_at DESC, task_id DESC LIMIT ${p(opts.limit)}`;
         const { rows } = await this.db.query(sql, params);
@@ -359,7 +390,7 @@ export class SqlRunStore {
             where.push(this.q("owner = ?", "owner = $3"));
             params.push(opts.owner);
         }
-        const { rows } = await this.db.query(`SELECT owner, created_at, status, result FROM task_run WHERE ${where.join(" AND ")} ORDER BY created_at LIMIT ${limit + 1}`, params);
+        const { rows } = await this.db.query(`SELECT owner, created_at, status, ${jsonColumnText(this.db.dialect, "result")} FROM task_run WHERE ${where.join(" AND ")} ORDER BY created_at LIMIT ${limit + 1}`, params);
         const truncated = rows.length > limit;
         const page = truncated ? rows.slice(0, limit) : rows;
         return {
@@ -368,7 +399,7 @@ export class SqlRunStore {
                 owner: r.owner ?? null,
                 createdAtMs: new Date(r.created_at).getTime(),
                 status: String(r.status),
-                ...(r.result != null ? { stats: projectUsageStats(r.result) } : {}),
+                ...(r.result === null ? {} : { stats: projectUsageStats(usageResultBody(r.result)) }),
             })),
         };
     }
@@ -378,11 +409,11 @@ export class SqlRunStore {
         return m == null ? 0 : Number(m);
     }
     async getEvents(taskId, afterSeq) {
-        const { rows } = await this.db.query(this.q("SELECT seq, type, data, ts FROM task_event WHERE task_id = ? AND seq > ? ORDER BY seq ASC", "SELECT seq, type, data, ts FROM task_event WHERE task_id = $1 AND seq > $2 ORDER BY seq ASC"), [taskId, afterSeq]);
+        const { rows } = await this.db.query(this.q(`SELECT seq, type, ${jsonColumnText("tidb", "data")}, ts FROM task_event WHERE task_id = ? AND seq > ? ORDER BY seq ASC`, `SELECT seq, type, ${jsonColumnText("pg", "data")}, ts FROM task_event WHERE task_id = $1 AND seq > $2 ORDER BY seq ASC`), [taskId, afterSeq]);
         return rows.map((r) => ({
             seq: Number(r.seq),
             type: String(r.type),
-            data: parseJson(r.data),
+            data: refusing("replay it as an empty ledger frame", () => decodeEventDataColumn(r.data, taskId, Number(r.seq))) ?? null,
             ts: iso(r.ts),
         }));
     }

package/dist/plugins/session-policy-store-sql.js

@@ -25,7 +25,11 @@ function rowToStored(r, where) {
     if (!Number.isFinite(rev) || !Number.isInteger(rev) || rev < 1) {
         throw new SessionPolicyError("corrupt", `session rules row ${where} carries rev ${String(r.rev)} — a stored row's rev is always ≥ 1 (the stamp is floor+1), and rev 0 is the live reader's synthetic empty seed; refusing rather than serve it as rules`);
     }
-    const gen = Number(r.gen ?? 0);
+    if (r.gen === undefined || r.gen === null) {
+        throw new Error(`session_policy row ${where} came back without a \`gen\` column — a read leg did not project it (the column is BIGINT NOT NULL on both dialects). ` +
+            "Refusing rather than judge this row's lineage as generation 0, which is a value nothing minted.");
+    }
+    const gen = Number(r.gen);
     if (!Number.isFinite(gen) || !Number.isInteger(gen) || gen < 0) {
         throw new SessionPolicyError("corrupt", `session rules row ${where} carries lineage gen ${String(r.gen)} — a generation is a whole number ≥ 0; refusing rather than let a reader judge lineage by a value nothing minted`);
     }

package/dist/plugins/sql-json-column.d.ts

@@ -92,6 +92,18 @@ export type JsonColumnReader<T> = (body: unknown) => JsonColumnShape<T>;
  * @param where 坐标文案(`<table>.<column> for <identity>`)。
  */
 export declare function decodeJsonColumn<T>(text: unknown, read: JsonColumnReader<T>, where: string): T;
+/**
+ * **可空列**的解码(整仓唯一入口)—— 把「这一格是空的」与「这一行根本没有这个键」**分开**。
+ *
+ * 🔴 两者在 JS 里长得几乎一样,后果却相反(codex 对抗复审第二轮 [high],验真后按类改;这条 `undefined
+ * ≡ 缺席` 的读法是**本批之前就有的**,不是本批引入 —— 但属主一落地它就变得可以一次修干净):
+ *  · `null` —— **SQL NULL**,两个驱动对空单元格都给它 ⇒ 这一格真的是空的(缺席),合法;
+ *  · `undefined` —— 行上**没有这个键** ⇒ SELECT 漏投影了这一列(或别名漂了)。那是**读腿的缺陷**,
+ *    而把它读成「空」在 steer / 决议 / 执行记录这些列上等于**替一条读不出的行编一个「什么都没有」**:
+ *    `setPendingSteer` 会在一条 rev 合法的 CAS 上把别人 park 的指令整段覆盖掉(实测复现过)。
+ * ⇒ `undefined` 一律落到 {@link decodeJsonColumn} 的 `not-text` 臂上,响亮抛、不折码、不被任何容忍臂吞。
+ */
+export declare function decodeNullableJsonColumn<T>(cell: unknown, read: JsonColumnReader<T>, where: string): T | undefined;
 /**
  * 店层折码的**唯一规则**(`catch (e) { throw foldJsonColumn(e, (m) => new XError("corrupt", m)); }`)。
  *
@@ -100,11 +112,35 @@ export declare function decodeJsonColumn<T>(text: unknown, read: JsonColumnReade
  * 非本模块的错误原样透出(连接 / 超时 / 权限本来就该照原样上抛)。
  */
 export declare function foldJsonColumn(e: unknown, corrupt: (message: string) => Error): Error;
+/**
+ * 折码的**容忍侧孪生**(与 {@link foldJsonColumn} 同一条判别,只写这一处):这一次失败是不是
+ * **数据体**的问题(`not-json` / `malformed`)。
+ *
+ * 🔴 用在那些**登记过的 F 类容忍面**上(设计 §2:容忍写在店的调用点,显式 `try/catch` +
+ * `recordFailOpen`)。`not-text` 与任何非本模块的错误(连接 / 超时 / 权限)在这里一律判**假** ⇒
+ * 调用点原样上抛:一条读腿漏了投影、或库连不上,绝不许被一条「这一格坏了,跳过它」的容忍臂吞掉 ——
+ * 那会让一次代码漂 / 一次故障伪装成「几行数据坏了」,而两者的处置完全不同。
+ */
+export declare function isJsonColumnBodyProblem(e: unknown): e is SqlJsonColumnError;
 /**
  * 把一只**既有的 zod schema** 当形读者用(本仓多数店的形判据就是它自己那份 schema)。
  * `create*` 而不是 `build*`:产物是一只函数([ref] N2 命名律)。
  */
 export declare function createZodColumnReader<T>(schema: z.ZodType<T>): JsonColumnReader<T>;
+/**
+ * **载荷形属主不在本仓 / 本层**的那一族列的形读者 —— 判「这一格是不是一只 JSON 对象」,然后把它当成
+ * 该店的域型交出去。整仓**只有这一处**做这一跳断言。
+ *
+ * 🔴 什么时候用它(硬条件,别扩大):这一列的键表属主在 **core**(`Checkpoint` / `ResumeOutcome` /
+ * `GateOutcome` / `WorkflowRun` / `BackgroundAgentRecord` …),而 core **没有导出验证器**。在 server 手写
+ * 一份等价 zod 就是设计稿明令禁止的**第二份键集**,它迟早与 core 分叉,而分叉那天是「写得进、读不出」。
+ * 一列只要有本仓自己的 schema 属主,就必须用 {@link createZodColumnReader} —— 用本函数等于把形判据关小。
+ *
+ * 🔴 为什么是一只工厂而不是让每个店各写一遍 `typeof body !== "object"`:那是同一条判据的 N 份拷贝
+ * (S-550 车② 初版真的写了六份),而且每一份都要自己那一跳 `as`。收成一处之后,判据只有一个写者,
+ * 断言也只发生在这一行 —— 类型卫生门因此在每个店里都读到零。
+ */
+export declare function createObjectColumnReader<T extends object>(): JsonColumnReader<T>;
 /**
  * **自由载荷列**的最小形读者:只判「这是一只 JSON 对象」,不碰键集。
  *
@@ -125,4 +161,17 @@ export declare function isJsonObject(v: unknown): v is Record<string, unknown>;
  * 一列只要有结构,就**不许**用它 —— 那是把形判据静默关掉。
  */
 export declare const readAnyJsonValueColumn: JsonColumnReader<unknown>;
+/**
+ * **任意 JSON 值,但缺席由「列 NULL」表达**的列的形读者 —— `null` 字面判坏,其余一律是值。
+ *
+ * 🔴 这是**写腿吃 `unknown` 的那一族列**的正解(codex 对抗复审 [high] 验真后定形,S-550 车②):
+ * 写腿接的是 `unknown`(`PendingAction.args` / 账本行载荷 / leader 结果……),于是**数组 / 串 / 数 /
+ * 布尔实参都写得进去** —— 拿 {@link readJsonObjectColumn} 判它们就是「写腿收得下、读腿读不出」,而且
+ * 后果往往不是一行坏:`rows.map` 里一条这样的合法行会让整只读面抛。
+ * 与 {@link readAnyJsonValueColumn} 的**唯一**区别是这一形:这族列的写腿把缺席(`undefined` / `null`)
+ * 统一落成 **SQL NULL**,所以列里的 `null` 字面按构造写不进来 —— 它只可能来自手改 / 迁移脚本,判坏。
+ * 用它之前先亲读写腿:缺席若**不是**落 SQL NULL(`approval_ask.updated_input` 的三态),用
+ * {@link readAnyJsonValueColumn}。
+ */
+export declare const readNonNullJsonValueColumn: JsonColumnReader<unknown>;
 //# sourceMappingURL=sql-json-column.d.ts.map

package/dist/plugins/sql-json-column.js

@@ -45,20 +45,30 @@ export function decodeJsonColumn(text, read, where) {
     }
     return shape.value;
 }
+export function decodeNullableJsonColumn(cell, read, where) {
+    return cell === null ? undefined : decodeJsonColumn(cell, read, where);
+}
 export function foldJsonColumn(e, corrupt) {
     if (e instanceof SqlJsonColumnError && e.problem !== "not-text")
         return corrupt(e.message);
     return e instanceof Error ? e : new Error(String(e));
 }
+export function isJsonColumnBodyProblem(e) {
+    return e instanceof SqlJsonColumnError && e.problem !== "not-text";
+}
 export function createZodColumnReader(schema) {
     return (body) => {
         const parsed = schema.safeParse(body);
         return parsed.success ? { value: parsed.data } : { problem: parsed.error.message };
     };
 }
+export function createObjectColumnReader() {
+    return (body) => (isJsonObject(body) ? { value: body } : { problem: "expected a JSON object" });
+}
 export const readJsonObjectColumn = (body) => isJsonObject(body) ? { value: body } : { problem: "expected a JSON object" };
 export function isJsonObject(v) {
     return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 export const readAnyJsonValueColumn = (body) => ({ value: body });
+export const readNonNullJsonValueColumn = (body) => body === null ? { problem: "the JSON literal `null` — absence is SQL NULL on this column, so a written `null` can only be a hand edit" } : { value: body };
 //# sourceMappingURL=sql-json-column.js.map

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

@@ -3,6 +3,7 @@ import { summarizeWorkflowRun, isTerminalWorkflowStatus, WorkflowRunStoreError }
 import { foldKeyFamily, MAX_PENDING_PER_SESSION, PURGE_FENCE_MS, SERVED_FENCE_MS, } from "../orchestration/workflow-completion-inbox.js";
 import {} from "../orchestration/workflow-agent-session-index.js";
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
+import { createObjectColumnReader, decodeJsonColumn, foldJsonColumn, jsonColumnText } from "./sql-json-column.js";
 import { isDupKeyError } from "./sql-errors.js";
 export const MAX_RUN_BLOB_BYTES = 4 * 1024 * 1024;
 const SLIM_HEADER_MAX = 200;
@@ -39,6 +40,15 @@ export function slimOversizeRun(run, maxBytes) {
     blob = JSON.stringify(step3);
     return Buffer.byteLength(blob) <= maxBytes ? blob : null;
 }
+const readWorkflowRunBody = createObjectColumnReader();
+function readRunColumn(v, id) {
+    try {
+        return decodeJsonColumn(v, readWorkflowRunBody, `workflow_run.run for run ${id}`);
+    }
+    catch (e) {
+        throw foldJsonColumn(e, (m) => new Error(`SqlWorkflowRunStore: ${m} — refusing rather than resume a hollow run`));
+    }
+}
 export class SqlWorkflowRunStore {
     db;
     onWarn;
@@ -62,11 +72,11 @@ export class SqlWorkflowRunStore {
         }
     }
     async get(id) {
-        const { rows } = await this.db.query(this.q("SELECT run, rev FROM workflow_run WHERE id = ?", "SELECT run, rev FROM workflow_run WHERE id = $1"), [id]);
+        const { rows } = await this.db.query(this.q(`SELECT ${jsonColumnText("tidb", "run")}, rev FROM workflow_run WHERE id = ?`, `SELECT ${jsonColumnText("pg", "run")}, rev FROM workflow_run WHERE id = $1`), [id]);
         const r = rows[0];
         if (!r)
             return null;
-        const run = JSON.parse(String(r.run));
+        const run = readRunColumn(r.run, id);
         run.rev = Number(r.rev);
         return run;
     }
@@ -119,9 +129,9 @@ export class SqlWorkflowRunStore {
                 limit = ` LIMIT $${params.length}`;
             }
         }
-        const { rows } = await this.db.query(`SELECT run, rev FROM workflow_run WHERE ${where} ORDER BY created_at_ms DESC, id DESC${limit}`, params);
+        const { rows } = await this.db.query(`SELECT id, ${jsonColumnText(this.db.dialect, "run")}, rev FROM workflow_run WHERE ${where} ORDER BY created_at_ms DESC, id DESC${limit}`, params);
         return rows.map((r) => {
-            const run = JSON.parse(String(r.run));
+            const run = readRunColumn(r.run, String(r.id));
             run.rev = Number(r.rev);
             return summarizeWorkflowRun(run);
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "7.93.5",
+  "version": "7.93.7",
   "description": "Sema Server — the server/API implementation layer for Sema, wiring core, registry, model providers, and cloud agent execution. Built on @sema-agent/core.",
   "type": "module",
   "license": "BUSL-1.1",