@sema-agent/server 7.136.0 → 7.137.0

package/dist/plugins/k8s-exec-protocol.js

@@ -1,35 +1,125 @@
-export function applyPodSpecPatch(pod, patch) {
-    assertHardeningOnly(patch.podSecurityContext, "podSecurityContext");
-    if (patch.podSecurityContext !== undefined && "sysctls" in patch.podSecurityContext) {
-        throw new Error("podSpecPatch.podSecurityContext rejected — `sysctls` is not a patch key (the pod's sysctls are minted only by the lane's IPv6 posture, K8S_SANDBOX_IPV6)");
+import { BROKER_VOLUME_NAME } from "../broker/constants.js";
+export const SANDBOX_POD_LABELS = { app: "sema-sandbox", "managed-by": "sema-server" };
+export const SANDBOX_RUN_LABEL = "sema.io/run";
+export const SANDBOX_RUN_END_HOLD_ANNOTATION = "sema.io/run-end-hold-ms";
+export const SANDBOX_SECRET_SEAT_VERBS = { env: ["create"], lease: ["create", "patch"] };
+const IDENTITY_LABEL_KEYS = new Set([...Object.keys(SANDBOX_POD_LABELS), SANDBOX_RUN_LABEL]);
+const LABEL_VALUE = /^(?:[A-Za-z0-9](?:[-A-Za-z0-9_.]{0,61}[A-Za-z0-9])?)?$/;
+export function isLabelValue(v) {
+    return LABEL_VALUE.test(v);
+}
+export const ADAPTER_VOLUME_NAMES = { cache: "ws-cache", brokerLease: BROKER_VOLUME_NAME };
+const RESERVED_VOLUME_NAMES = new Set(Object.values(ADAPTER_VOLUME_NAMES));
+const agentContainerOf = (pod) => pod.spec.containers?.[0];
+const POD_SPEC_PATCH_FIELDS = {
+    volumes: {
+        judge: (volumes) => {
+            assertVolumesPodLocal(volumes, "volumes");
+            for (const v of volumes)
+                assertPatchVolumeName(v?.name, "volumes");
+        },
+        apply: (pod, volumes) => {
+            if (volumes.length > 0)
+                pod.spec.volumes = [...(pod.spec.volumes ?? []), ...volumes];
+        },
+        withBroker: "allowed",
+    },
+    volumeMounts: {
+        judge: (mounts) => {
+            for (const m of mounts)
+                assertPatchVolumeName(m?.name, "volumeMounts");
+        },
+        apply: (pod, mounts) => {
+            const container = agentContainerOf(pod);
+            if (container && mounts.length > 0)
+                container.volumeMounts = [...(container.volumeMounts ?? []), ...mounts];
+        },
+        withBroker: "allowed",
+    },
+    podSecurityContext: {
+        judge: (sc) => {
+            assertHardeningOnly(sc, "podSecurityContext");
+            if ("sysctls" in sc) {
+                throw new Error("podSpecPatch.podSecurityContext rejected — `sysctls` is not a patch key (the pod's sysctls are minted only by the lane's IPv6 posture, K8S_SANDBOX_IPV6)");
+            }
+        },
+        apply: (pod, sc) => {
+            pod.spec.securityContext = { ...(pod.spec.securityContext ?? {}), ...sc };
+        },
+        withBroker: {
+            refused: "podSpecPatch.podSecurityContext is not allowed on a pod that carries the member-credential broker — every pod-level key would reach the broker container too; put the hardening into containerSecurityContext (it lands on the agent container only)",
+        },
+    },
+    containerSecurityContext: {
+        judge: (sc) => assertHardeningOnly(sc, "containerSecurityContext"),
+        apply: (pod, sc) => {
+            const container = agentContainerOf(pod);
+            if (container)
+                container.securityContext = { ...(container.securityContext ?? {}), ...sc };
+        },
+        withBroker: "allowed",
+    },
+    labels: {
+        judge: () => { },
+        apply: (pod, labels) => {
+            const merged = { ...pod.metadata.labels };
+            for (const [k, v] of Object.entries(labels))
+                if (!IDENTITY_LABEL_KEYS.has(k))
+                    merged[k] = v;
+            pod.metadata.labels = merged;
+        },
+        withBroker: "allowed",
+    },
+};
+const PATCH_FIELD_ORDER = Object.keys(POD_SPEC_PATCH_FIELDS);
+export function applyPodSpecPatch(pod, patch, presence = { broker: false }) {
+    const present = judgePodSpecPatch(patch, presence);
+    for (const k of present)
+        applyField(k, pod, patch);
+}
+export function podSpecPatchBrokerRefusal(patch) {
+    if (patch === undefined)
+        return undefined;
+    try {
+        judgePodSpecPatch(patch, { broker: true });
+        return undefined;
+    }
+    catch (e) {
+        return e instanceof Error ? e.message : String(e);
     }
-    assertHardeningOnly(patch.containerSecurityContext, "containerSecurityContext");
-    if (patch.labels) {
-        const identity = {};
-        for (const k of ["app", "managed-by"]) {
-            const v = pod.metadata.labels?.[k];
-            if (v !== undefined)
-                identity[k] = v;
+}
+function judgePodSpecPatch(patch, presence) {
+    for (const key of Object.keys(patch)) {
+        if (!Object.hasOwn(POD_SPEC_PATCH_FIELDS, key)) {
+            throw new Error(`podSpecPatch rejected — ${JSON.stringify(key)} is not a patch field (the patch fields are ${PATCH_FIELD_ORDER.join(" / ")}; any other key is refused, never ignored)`);
         }
-        pod.metadata.labels = { ...pod.metadata.labels, ...patch.labels, ...identity };
     }
-    const spec = pod.spec;
-    assertVolumesPodLocal(patch.volumes, "volumes");
-    if (patch.volumes?.length)
-        spec.volumes = [...(spec.volumes ?? []), ...patch.volumes];
-    if (patch.podSecurityContext)
-        spec.securityContext = { ...(spec.securityContext ?? {}), ...patch.podSecurityContext };
-    const container = spec.containers?.[0];
-    if (container) {
-        if (patch.volumeMounts?.length)
-            container.volumeMounts = [...(container.volumeMounts ?? []), ...patch.volumeMounts];
-        if (patch.containerSecurityContext)
-            container.securityContext = { ...(container.securityContext ?? {}), ...patch.containerSecurityContext };
+    const present = PATCH_FIELD_ORDER.filter((k) => patch[k] !== undefined);
+    if (presence.broker) {
+        for (const k of present) {
+            const column = POD_SPEC_PATCH_FIELDS[k].withBroker;
+            if (column !== "allowed")
+                throw new Error(column.refused);
+        }
+    }
+    for (const k of present)
+        judgeField(k, patch);
+    return present;
+}
+function judgeField(key, patch) {
+    POD_SPEC_PATCH_FIELDS[key].judge(patch[key]);
+}
+function applyField(key, pod, patch) {
+    POD_SPEC_PATCH_FIELDS[key].apply(pod, patch[key]);
+}
+function assertPatchVolumeName(name, where) {
+    if (typeof name !== "string" || name === "")
+        throw new Error(`podSpecPatch.${where} rejected — every entry needs a non-empty string \`name\``);
+    if (RESERVED_VOLUME_NAMES.has(name)) {
+        throw new Error(`podSpecPatch.${where} rejected — volume name ${JSON.stringify(name)} is reserved (the adapter mints it on the pod itself: ${[...RESERVED_VOLUME_NAMES].join(" / ")}); name the patch volume something else`);
     }
 }
 function assertHardeningOnly(sc, where) {
-    if (!sc)
-        return;
     const bad = (msg) => {
         throw new Error(`podSpecPatch.${where} rejected — it may only HARDEN, never weaken isolation: ${msg}`);
     };
@@ -53,8 +143,6 @@ function assertHardeningOnly(sc, where) {
         bad('seccompProfile.type:"Unconfined" (disables syscall filtering)');
 }
 function assertVolumesPodLocal(volumes, where) {
-    if (!volumes?.length)
-        return;
     const POD_LOCAL = new Set(["emptyDir", "configMap", "secret", "projected", "downwardAPI", "ephemeral"]);
     for (const v of volumes) {
         const vol = v;

package/dist/plugins/k8s-pod-delete-failure.d.ts

@@ -0,0 +1,25 @@
+/** A pod DELETE the API answered with something other than "deleted" (2xx) or "not there" (404): a Role without `delete`, a 5xx — the pod is still in the namespace. */
+export declare class PodDeleteRefused extends Error {
+    readonly status: number;
+    constructor(status: number);
+}
+/** 删失败的原因码(闭集两形):API 回了 2xx / 404 以外的答复 ⇒ `http_<状态>`;请求本身抛(传输失败 / 超时)⇒ `request_failed`。 */
+export declare function podDeleteCauseOf(error: unknown): string;
+/** 一次删失败的读数(座自己填 `why` 与 `effect`)。 */
+export interface PodDeleteFailure {
+    readonly namespace: string;
+    readonly pod: string;
+    /** 这只 pod 为什么要删(每个座一个闭集词)。 */
+    readonly why: string;
+    /** 被抛出的那一只(只读它的类型取原因码,其文字不上任何一行)。 */
+    readonly error: unknown;
+    /** 留下什么(运维行的后果句,英文,不带值)。 */
+    readonly effect: string;
+    /** 运维行座:可缺 / 可没有 `error` 档(计数不依赖座)。 */
+    readonly logger?: {
+        error?(event: string, fields?: Record<string, unknown>): void;
+    };
+}
+/** 上报一次删 pod 失败(计数 + 一行 error)。不抛。 */
+export declare function reportPodDeleteFailed(f: PodDeleteFailure): void;
+//# sourceMappingURL=k8s-pod-delete-failure.d.ts.map

package/dist/plugins/k8s-pod-delete-failure.js

@@ -0,0 +1,17 @@
+import { recordFailOpen } from "../observability/fail-open.js";
+export class PodDeleteRefused extends Error {
+    status;
+    constructor(status) {
+        super(`pod delete answered HTTP ${status}`);
+        this.status = status;
+    }
+}
+export function podDeleteCauseOf(error) {
+    return error instanceof PodDeleteRefused ? `http_${error.status}` : "request_failed";
+}
+export function reportPodDeleteFailed(f) {
+    const cause = podDeleteCauseOf(f.error);
+    recordFailOpen("server.sandbox-pod.delete-failed", `namespace=${f.namespace} pod=${f.pod} why=${f.why} cause=${cause}`);
+    f.logger?.error?.("sandbox_pod_delete_failed", { pod: f.pod, namespace: f.namespace, why: f.why, cause, effect: f.effect });
+}
+//# sourceMappingURL=k8s-pod-delete-failure.js.map

package/dist/plugins/k8s-pod-reaper.d.ts

@@ -0,0 +1,112 @@
+/**
+ * k8s 沙箱 Pod 的 reaper —— server 建出来、却没被自己的 run 收尾删掉的 Pod 由它删(该 Pod 的 Secret 以 `ownerReferences` 属于它,随它由集群 GC)。
+ *
+ * 为什么要它:`activeDeadlineSeconds` 只让容器到点终止、Pod 进 `Failed`,**不删 Pod 对象**;run 收尾的 `destroy()` 是删 Pod 的正常路,
+ * 而 server 进程崩溃 / 收尾里删失败(`destroy` 的删是吞错的)时 Pod 对象(连同它的 Secret)就一直留着。
+ *
+ * 法(只删两形;判决链的缺省臂是「不动作」,删必须被显式选中 —— 销毁不可逆,拿不准恒不删,与 E2B 孤儿回收同一方向纪律):
+ *  ② `status.phase ∈ {Succeeded, Failed}` —— 容器已全部结束,删它不掐断任何东西;不看 run、不看标签;
+ *  ① 带 run 标签(`sema.io/run`,只有顶层 run 的 Pod 带)、run 行在 server 店里**已是终态**,且自 run 行**转终态的时刻**(行上的 `updatedAt` ——
+ *     三只 run 店的终态写当拍盖它)起超过**这只 Pod 自带的**上界:`max(租约上限 + 宽限 = 6 min, 工作区快照时限 + 引擎拆环境放行 15 s)`
+ *     ({@link sandboxRunEndHoldMs};租约上限 = 凭据代理的租约律那一只 `LEASE_TTL_MAX_MS`,本模块不另立)。
+ *     第二项是 run 收尾的 `destroy()` 在终态之后还可能在 Pod 上存快照的最长时间(引擎的拆环境腿 15 s 放行、run 随即落终态,快照按数据时限接着跑)——
+ *     那个数据时限是**建这只 Pod 的副本**的配置,所以上界**随 Pod 走、写一次读一次**:适配器建 Pod 时按自己的快照时限算一次、写进注解
+ *     `sema.io/run-end-hold-ms`(`k8s-exec-protocol.ts` `SANDBOX_RUN_END_HOLD_ANNOTATION`),回收器只读 Pod 自带的这一格,**从不**读回收器所在副本的配置
+ *     (列举是整个命名空间的 Pod:滚动改 `WORKSPACE_SNAPSHOT_TIMEOUT_MS` 时,一个时限短的副本不得替时限长的副本判它的 Pod)。
+ *     带 run 标签的 Pod 上注解缺席(不是本服务写的:标签与注解由建 Pod 的适配器在同一个条件下一起写)、不是十进制整数、不在 [租约上限 + 宽限, 快照时限上限 + 引擎拆环境放行] 里
+ *     ⇒ 不按 ① 删(`hold_unreadable`;这只 Pod 由自己的 `activeDeadlineSeconds` 到点后命中 ② 收)。7.136.x 及以前建的 Pod 没有 run 标签(标签与注解都是本版起写)⇒ 落在下面
+ *     「不带 run 标签」一类(`no_run_label`),同样只按 ② 收。持久化开 / 关两种部署同一条律。
+ *     **活 run 的 Pod 不由本模块判**:run 行非终态(活 / 停驻)、查不到、读抛、词表外 ⇒ 不删 —— 它由自己的截止(`activeDeadlineSeconds` 到点
+ *     ⇒ 之后命中 ②)与取消 / 收尾路径收;本模块从不按 Pod 存在时长判活。
+ * 不带 run 标签的 Pod(委派子代 / 服务自己的 run / 没有 run id)只按 ② 删:会话级后台子代刻意活过父 run 的回合,「会话里没有非终态 run」
+ * 推不出「这只 Pod 没人用」。
+ *
+ * 没有 run 店(无存储后端的部署)⇒ ② 照删;带 run 标签的 Pod 跳过 `run_store_absent`(查不了 run ⇒ 不删)。
+ * 每轮一行结构化日志 `sandbox_pod_reap_round`(扫了几只、按闭集原因分的删 / 跳过计数),每删一只一行 `sandbox_pod_reaped`;**列举失败**这一轮一只都删不了 ——
+ * F 类兜底口 `server.sandbox-pod-reaper.list-failed` 计一次 + 一行 warn `sandbox_pod_reap_list_failed`(下一轮一个周期后照常再列);**某一只删失败**不挡其余 ——
+ * 与连接清理同一只上报口 `reportPodDeleteFailed`(F 类计数 `server.sandbox-pod.delete-failed` + 一行 error `sandbox_pod_delete_failed`,`why=reaper_<删它的理由>`,下一轮再判再删)。
+ * 每副本起服后第一个维护 tick 跑一次、此后每 {@link SANDBOX_POD_REAP_PERIOD_MS} 一次(`boot/reapers.ts`);多副本同时删同一只 ⇒ 404 计 `gone`。
+ */
+import type { Logger } from "../observability/logger.js";
+import type { Metrics } from "../observability/metrics.js";
+/** ① 的宽限(在租约上限之外再等的一段)。常量。 */
+export declare const SANDBOX_POD_REAP_GRACE_MS = 60000;
+/**
+ * 引擎在 run 收尾时给「拆执行环境」那条腿的放行时限:超过它 run 照样落终态,`destroy()` 脱离着继续跑。值 = core 的 `TEARDOWN_LEG_MAX_MS`
+ * (`dist/core/runner/teardown-bounded.js`)—— core 不从包根导出它(包的 exports 只有 `.` / `./bench` / `./fixtures`),本仓只能照抄这一个数;
+ * 收口 = 向 core 要一个包根读口后改读、删本常量。
+ */
+export declare const ENGINE_TEARDOWN_RELEASE_MS = 15000;
+/** ① 的上界:`max(租约上限 + 宽限, 快照时限 + 引擎拆环境放行)`。唯一的调用方 = 适配器建 Pod 的那一拍(快照时限 = 建它的副本的 `dataTimeoutMs`),结果写进 Pod 的注解。 */
+export declare function sandboxRunEndHoldMs(snapshotTimeoutMs: number): number;
+/** 一个副本两轮回收之间的间隔。常量。 */
+export declare const SANDBOX_POD_REAP_PERIOD_MS: number;
+/** 列举出来的一只沙箱 Pod(只带判官要读的几样;时刻是毫秒)。 */
+export interface SandboxPodListing {
+    readonly name: string;
+    /** 标签 `sema.io/run`:顶层 run 的 id;缺席 = 这只 Pod 不点名 run。 */
+    readonly runId?: string;
+    /** 注解 `sema.io/run-end-hold-ms` 的原串(建它的副本写的 ① 上界);缺席 = Pod 上没有这一格(或不是串)。判官自己读它({@link judgeSandboxPod})。 */
+    readonly runEndHold?: string;
+    readonly phase?: string;
+    /** `metadata.deletionTimestamp` 在场:已在删除中。 */
+    readonly terminating: boolean;
+}
+/** reaper 对沙箱命名空间的窄面(真实装配 = `remote-env-k8s.ts` 的 `createSandboxPodApi`;测试注入假面)。 */
+export interface SandboxPodApi {
+    readonly namespace: string;
+    /** 按身份标签列本命名空间的沙箱 Pod。失败抛。 */
+    list(): Promise<SandboxPodListing[]>;
+    /** 删一只;404 ⇒ `gone`。其余失败抛。 */
+    delete(name: string): Promise<"deleted" | "gone">;
+}
+/** 一行 run 在判官眼里的两位。状态词按**串**读:滚动升级里新副本写下的词本进程可能不认(`runStatusClassOf` 答 `undefined` ⇒ 不删)。
+ *  `updatedAt` = 行最后一次被写的时刻(ISO);终态行上它就是转终态那一拍(之后改它的写只会让 reaper 等得更久)。 */
+export interface SandboxPodRunRow {
+    readonly status: string;
+    readonly updatedAt: string;
+}
+/** run 店的窄读口(三只 run 店共有的 `getRun`)。 */
+export interface SandboxPodRunReader {
+    getRun(taskId: string): Promise<SandboxPodRunRow | null | undefined>;
+}
+/** 一只 Pod 的 run 读数(闭集):读到行 / 店答没有这一行 / 读抛 / 本部署没有 run 店可问。 */
+export type SandboxPodRunReading = {
+    readonly found: SandboxPodRunRow;
+} | {
+    readonly absent: true;
+} | {
+    readonly failed: true;
+} | {
+    readonly storeAbsent: true;
+};
+export type SandboxPodDeleteReason = "containers_ended" | "run_ended_past_hold";
+export type SandboxPodSkipReason = "terminating" | "no_run_label" | "run_store_absent" | "run_unread" | "run_read_failed" | "run_status_unknown" | "run_live" | "run_end_unreadable" | "hold_unreadable" | "within_run_end_hold";
+export type SandboxPodVerdict = {
+    readonly delete: SandboxPodDeleteReason;
+} | {
+    readonly skip: SandboxPodSkipReason;
+};
+/** 一只 Pod 删不删(纯判官;法见文件头)。`now` 毫秒;① 的上界只读 Pod 自带的注解(`pod.runEndHold`),没有第二个来源。 */
+export declare function judgeSandboxPod(pod: SandboxPodListing, run: SandboxPodRunReading, now: number): SandboxPodVerdict;
+/** 一轮的读数(轮次行与计数的来源)。`deleted` / `skipped` 只列出现过的原因。 */
+export interface SandboxPodReapRound {
+    readonly listed: boolean;
+    readonly scanned: number;
+    readonly deleted: Partial<Record<SandboxPodDeleteReason, number>>;
+    readonly skipped: Partial<Record<SandboxPodSkipReason, number>>;
+    /** 判了删、删时已不在(404)。 */
+    readonly gone: number;
+    readonly deleteFailed: number;
+}
+export interface SandboxPodReaper {
+    /** 一轮:列举 → 逐只判 → 删被判删的。不抛(列举失败 ⇒ `listed: false` + F 计数 + 一行 warn)。`runs` 缺席 = 本部署没有 run 店(② 照删)。 */
+    reapOnce(runs: SandboxPodRunReader | undefined): Promise<SandboxPodReapRound>;
+}
+export declare function createSandboxPodReaper(deps: {
+    readonly api: SandboxPodApi;
+    readonly logger?: Pick<Logger, "info" | "warn" | "error">;
+    readonly metrics?: Pick<Metrics, "inc">;
+    readonly now?: () => number;
+}): SandboxPodReaper;
+//# sourceMappingURL=k8s-pod-reaper.d.ts.map

package/dist/plugins/k8s-pod-reaper.js

@@ -0,0 +1,122 @@
+import { recordFailOpen } from "../observability/fail-open.js";
+import { reportPodDeleteFailed } from "./k8s-pod-delete-failure.js";
+import { runStatusClassOf } from "./store-contracts.js";
+import { LEASE_TTL_MAX_MS } from "../broker/lease-file.js";
+import { WORKSPACE_SNAPSHOT_TIMEOUT_MS_RANGE } from "../workspace-space.js";
+export const SANDBOX_POD_REAP_GRACE_MS = 60_000;
+export const ENGINE_TEARDOWN_RELEASE_MS = 15_000;
+export function sandboxRunEndHoldMs(snapshotTimeoutMs) {
+    return Math.max(LEASE_TTL_MAX_MS + SANDBOX_POD_REAP_GRACE_MS, snapshotTimeoutMs + ENGINE_TEARDOWN_RELEASE_MS);
+}
+const RUN_END_HOLD_READABLE = { min: LEASE_TTL_MAX_MS + SANDBOX_POD_REAP_GRACE_MS, max: WORKSPACE_SNAPSHOT_TIMEOUT_MS_RANGE.max + ENGINE_TEARDOWN_RELEASE_MS };
+function runEndHoldOf(raw) {
+    if (raw === undefined || !/^[0-9]{1,16}$/.test(raw))
+        return undefined;
+    const ms = Number(raw);
+    return Number.isSafeInteger(ms) && ms >= RUN_END_HOLD_READABLE.min && ms <= RUN_END_HOLD_READABLE.max ? ms : undefined;
+}
+export const SANDBOX_POD_REAP_PERIOD_MS = 5 * 60_000;
+const CLASS_VERDICT = {
+    live: "live",
+    parked: "live",
+    succeeded: "terminal",
+    unsuccessful: "terminal",
+};
+export function judgeSandboxPod(pod, run, now) {
+    if (pod.terminating)
+        return { skip: "terminating" };
+    if (pod.phase === "Succeeded" || pod.phase === "Failed")
+        return { delete: "containers_ended" };
+    if (pod.runId === undefined)
+        return { skip: "no_run_label" };
+    if ("storeAbsent" in run)
+        return { skip: "run_store_absent" };
+    if ("failed" in run)
+        return { skip: "run_read_failed" };
+    if ("absent" in run)
+        return { skip: "run_unread" };
+    const cls = runStatusClassOf(run.found.status);
+    if (cls === undefined)
+        return { skip: "run_status_unknown" };
+    if (CLASS_VERDICT[cls] === "live")
+        return { skip: "run_live" };
+    const endedAt = Date.parse(run.found.updatedAt);
+    if (!Number.isFinite(endedAt))
+        return { skip: "run_end_unreadable" };
+    const hold = runEndHoldOf(pod.runEndHold);
+    if (hold === undefined)
+        return { skip: "hold_unreadable" };
+    if (now - endedAt <= hold)
+        return { skip: "within_run_end_hold" };
+    return { delete: "run_ended_past_hold" };
+}
+export function createSandboxPodReaper(deps) {
+    const now = deps.now ?? Date.now;
+    return {
+        async reapOnce(runs) {
+            const deleted = {};
+            const skipped = {};
+            let gone = 0;
+            let deleteFailed = 0;
+            let pods;
+            try {
+                pods = await deps.api.list();
+            }
+            catch (e) {
+                const error = e instanceof Error ? e.message : String(e);
+                recordFailOpen("server.sandbox-pod-reaper.list-failed", `namespace=${deps.api.namespace} ${error}`);
+                deps.logger?.warn("sandbox_pod_reap_list_failed", {
+                    namespace: deps.api.namespace,
+                    error,
+                    effect: "sandbox pods were not deleted this round — ended pods and pods of ended runs (with their Secrets) stay until a later round lists them (one period later)",
+                });
+                return { listed: false, scanned: 0, deleted, skipped, gone, deleteFailed };
+            }
+            const reads = new Map();
+            const readRun = (runId) => {
+                if (runs === undefined)
+                    return Promise.resolve({ storeAbsent: true });
+                let r = reads.get(runId);
+                if (r === undefined) {
+                    r = runs.getRun(runId).then((row) => (row === undefined || row === null ? { absent: true } : { found: row }), () => ({ failed: true }));
+                    reads.set(runId, r);
+                }
+                return r;
+            };
+            const at = now();
+            for (const pod of pods) {
+                const reading = pod.runId === undefined ? { absent: true } : await readRun(pod.runId);
+                const verdict = judgeSandboxPod(pod, reading, at);
+                if ("skip" in verdict) {
+                    skipped[verdict.skip] = (skipped[verdict.skip] ?? 0) + 1;
+                    continue;
+                }
+                try {
+                    const outcome = await deps.api.delete(pod.name);
+                    if (outcome === "gone") {
+                        gone++;
+                        continue;
+                    }
+                    deleted[verdict.delete] = (deleted[verdict.delete] ?? 0) + 1;
+                    deps.metrics?.inc("sandbox_pods_reaped_total", { reason: verdict.delete });
+                    deps.logger?.info("sandbox_pod_reaped", { namespace: deps.api.namespace, pod: pod.name, reason: verdict.delete, ...(pod.runId !== undefined ? { run: pod.runId } : {}) });
+                }
+                catch (e) {
+                    deleteFailed++;
+                    reportPodDeleteFailed({
+                        namespace: deps.api.namespace,
+                        pod: pod.name,
+                        why: `reaper_${verdict.delete}`,
+                        error: e,
+                        effect: "the pod, and the Secret it owns, stay in the sandbox namespace; the reaper tries this pod again next round (one period later), until then it holds static data only",
+                        logger: deps.logger,
+                    });
+                }
+            }
+            const round = { listed: true, scanned: pods.length, deleted, skipped, gone, deleteFailed };
+            deps.logger?.info("sandbox_pod_reap_round", { namespace: deps.api.namespace, ...round });
+            return round;
+        },
+    };
+}
+//# sourceMappingURL=k8s-pod-reaper.js.map

package/dist/plugins/local-checkpoint-store.d.ts

@@ -1,5 +1,5 @@
 import { type Checkpoint, type CheckpointSummary, type CheckpointToken, type PendingSteerInput, type ReopenReason, type ResolveExpectation, type ExecutionOutcomeRecordWord, type GateOutcome, type ResumeOutcome, type StoreDurability, type StoreFidelity } from "@sema-agent/core";
-import { type CheckpointAskCandidate, type CtxRowsRewriteM28, type DecidedApprovalRecord, type PendingCheckpoint, type PendingRowBinding } from "./checkpoint-store-sql.js";
+import { type CheckpointAskCandidate, type CtxRowRewrite, type CtxRowsRewrite, type DecidedApprovalRecord, type PendingCheckpoint, type PendingRowBinding } from "./checkpoint-store-sql.js";
 import type { SealedCheckpointCtx } from "../http/checkpoint-ctx.js";
 export interface LocalCheckpointStoreOptions {
     /** taskId join for the pending card (the local FileRunStore's `getActiveTaskId`). Absent ⇒ `taskId: null`. */
@@ -213,15 +213,12 @@ export declare class LocalCheckpointStore {
      */
     getCtx<T extends object = object>(sessionId: string): Promise<T | null>;
     /**
-     * 🔴 **一次性迁移 M28 的店腿**(local 孪生;窗与删法见 `plugins/one-time-migrations.ts` 登记表 M28,判词与 SQL 孪生 `rewriteCtxRowsM28` 逐条同):
+     * 🔴 **一次性迁移的 ctx 行改写店腿**(local 孪生;`checkpoint-store-sql.ts` `CheckpointCtxRowsRewriter`,判词与 SQL 孪生 `rewriteCtxRows` 逐条同):
      * 逐档读(信封经读腿**同一只**判形 —— 读不出 ⇒ 计数、跳过、**不删**),`rewrite` 交回新体 ⇒ 信封原样(`sessionId` / `updatedAt` 不动:收割按 `updatedAt` 判)
      * 只换 `ctx`,经写腿同一只形闸、同一只原子写落回原档。封签绑的是信封里的 `sessionId`(与 `getCtx` 认行的那一格同一个)。
      * 数据根独占 + 起服在任何读写者之前跑 ⇒ 本车道没有并发写者,不需要 CAS;没有一行装不下这回事(`tooLarge` 恒 0)。
      */
-    rewriteCtxRowsM28(rewrite: (sessionId: string, ctx: object) => {
-        readonly ctx: SealedCheckpointCtx;
-        readonly values: number;
-    } | undefined): Promise<CtxRowsRewriteM28>;
+    rewriteCtxRows(rewrite: CtxRowRewrite): Promise<CtxRowsRewrite>;
     /** GC ctx files whose lifecycle is over — same three guards as the SQL twins (stale ∧ no pending ∧ no active run). */
     reapCtx(cutoff: number): Promise<number>;
     /**

package/dist/plugins/local-checkpoint-store.js

@@ -327,7 +327,7 @@ export class LocalCheckpointStore {
         const rec = refusingCtx(sessionId, () => decodeJsonColumn(readFileSync(p, "utf8"), createCtxRecordReader(), `checkpoint-ctx ${ctxFileOf(sessionId)} for session ${JSON.stringify(sessionId)}`));
         return rec.sessionId === sessionId ? rec.ctx : null;
     }
-    async rewriteCtxRowsM28(rewrite) {
+    async rewriteCtxRows(rewrite) {
         const out = { scanned: 0, rewritten: 0, valuesRewritten: 0, unreadable: 0, tooLarge: 0 };
         for (const f of readdirSync(this.ctxDir)) {
             if (!f.endsWith(".json"))
@@ -335,7 +335,7 @@ export class LocalCheckpointStore {
             const p = join(this.ctxDir, f);
             let rec;
             try {
-                rec = decodeJsonColumn(readFileSync(p, "utf8"), createCtxRecordReader(), `checkpoint-ctx ${f} (M28 scan)`);
+                rec = decodeJsonColumn(readFileSync(p, "utf8"), createCtxRecordReader(), `checkpoint-ctx ${f} (ctx row rewrite scan)`);
             }
             catch {
                 out.unreadable += 1;
@@ -346,7 +346,7 @@ export class LocalCheckpointStore {
             if (next === undefined)
                 continue;
             const text = JSON.stringify({ sessionId: rec.sessionId, updatedAt: rec.updatedAt, ctx: next.ctx });
-            assertJsonColumnWritable(text, createCtxRecordReader(), `checkpoint ctx for session ${JSON.stringify(rec.sessionId)} (local M28 write)`);
+            assertJsonColumnWritable(text, createCtxRecordReader(), `checkpoint ctx for session ${JSON.stringify(rec.sessionId)} (local ctx row rewrite)`);
             atomicWriteFile(this.tmpDir, p, text);
             out.rewritten += 1;
             out.valuesRewritten += next.values;

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

@@ -43,6 +43,7 @@ export class MemoryRunStore {
             errorCode: r.errorCode,
             jobId: r.jobId,
             source: r.source,
+            identity: r.identity,
             instanceId: r.instanceId,
             cancelRequested: r.cancelRequested,
             objectivePreview: r.objectivePreview,
@@ -75,6 +76,7 @@ export class MemoryRunStore {
             objectivePreview: meta.objectivePreview ?? null,
             idemKey,
             idemBodyFingerprint: meta.idem?.bodyFingerprint ?? null,
+            identity: meta.identity ?? null,
             createdAt: now,
             updatedAt: now,
             cancelRequested: false,

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

@@ -109,11 +109,12 @@
  *       改名之后它们找不到那一列:已在跑的旧副本每一条规则语句响亮失败(新任务起不来、规则面 500,在跑的腿留着它已执行的快照),旧二进制起服被列册探针拒启 ——
  *       没有一只副本按旧文法读到新文法的行。行里不带文法版本(一个旧写者维护不了的第二个事实,恰在混跑窗里说谎),也不读规则体猜版本。
  *       MySQL 协议方言 `CHANGE COLUMN`(MariaDB 10.5 以前没有 `RENAME COLUMN`;定义内插同一串),PG `RENAME COLUMN`;成功判据是后置条件(列名换过来了)。
- *    ② **改名那一拍的改写:每一行在它自己的文法里由引擎读,改写成当前文法的同一句话**(core 7.51.2 [ref],行自带规则文法戳 `grammar`:写口判官盖、店整只存、
+ *    ② **改名那一拍的改写:每一行在它自己的文法里由引擎读,改写成文法 1 里的同一句话**(core 7.51.2 [ref],行自带规则文法戳 `grammar`:写口判官盖、店整只存、
  *       引擎按行自带的戳读;无戳行 = 戳之前写的行,引擎读成文法 0)。改名那一刻库里每一行都是无戳行(≤7.128.x 写的)—— 判据只有引擎的:行(体 + `rev`)经
  *       `readSessionRulesShape` 读成它自己的文法,`compileSessionRuleBucket` 在那种文法下编译 `toolAllow`,归 `earlier_grammar` 的条目(文法 0 里拼写不是它所指名字的条目
- *       —— `Bash(rm:*)` / `Edit(src/**)` / `Bash(*)`:什么都不放行,文法 1 里是一条放行规则)删掉,其余原样,盖 `grammar: SESSION_RULES_GRAMMAR` —— 文法 0 与 1 在引擎里只差
- *       这一条子句,所以改写后的行是引擎对原行读法的逐调用同义重述(名单保持在场:删到空 = 在场的空名单,什么都不放行)。**每一行**都改写(只盖戳的也写):改写之后
+ *       —— `Bash(rm:*)` / `Edit(src/**)` / `Bash(*)`:什么都不放行,文法 1 里是一条放行规则)删掉,其余原样,盖 `grammar: 1` —— 文法 0 与 1 在引擎里只差
+ *       这一条子句,所以改写后的行在文法 1 里是原行的逐调用同义重述(名单保持在场:删到空 = 在场的空名单,什么都不放行);之后几次修订由引擎按行戳读、保住写者的意思
+ *       (7.137.0 起;此前盖的是当时的当前文法,引擎 7.56.0 把名内 `*` 的意思改了之后那一盖会越过修订、静默把 `toolDeny: ["*"]` 变成拒每一只工具)。**每一行**都改写(只盖戳的也写):改写之后
  *       部署里零无戳行,除下一条留下的行(引擎 7.52.0 [ref] 起文法 0 里的 `*` 也是 `earlier_grammar` 惰性条目、只作废它自己 —— 与别的读不出的 allow 条目同一条判:删、盖戳;7.129.0–7.131.x 引擎把带 `*` 的名单整张读成作废,本步对那种行曾不改写、只点名,那一臂随引擎修正退役)。
  *       **盖戳前先问引擎读者**([ref],引擎 7.52.0 [ref]):行的 `toolDeny` 里有 `unreadableDenyEntries` 答的条目(引擎在这一行的文法里读成「不是任何一条规则」:空串、`-deploy`、非 ASCII 名、`(` 前带不可见空白 ……
  *       7.129.0–7.131.x 的写口收下过)⇒ 引擎对这一行的**每一次工具调用都拒**(读成更少的规则是 fail-open,引擎不这么读),并按行自带的旧文法通告(`config.session_rules_earlier_grammar`,只对戳早于当前文法的行发)。
@@ -252,7 +253,7 @@
  *    `http/checkpoint-ctx.ts` 末段「凭据位密封」;本处不重列)在 `checkpoint_ctx` 里只以封签存在,续跑上下文读口对凭据位上的明文答 409 `conflict.checkpoint_ctx_unsealable`(`reason:"plaintext"`)。升级之前写下的
  *    行是明文 ⇒ **起服扫一遍、原地封好**:不在本文件的迁移段里(封要保管店的封签器,而本段跑在建店的 web-admin 运行时能交给它之前的店层 ——
  *    与 M10 / M19 / M25 同为在本段之外跑的条目),编排在 `checkpoint-ctx-seal-m28.ts`(起服第 6 段,checkpoint 店建成之后、任何路由装配之前调一次),
- *    店腿是两孪生各自的 `rewriteCtxRowsM28`(SQL:键集分页 + 按原文 CAS、`updated_at_ms` 不动;local:逐档原子重写、信封的 `updatedAt` 不动),
+ *    店腿是两孪生共有的 ctx 行改写腿 `rewriteCtxRows`(`checkpoint-store-sql.ts` `CheckpointCtxRowsRewriter`;M30 用同一只;SQL:键集分页 + 按原文 CAS、`updated_at_ms` 不动;local:逐档原子重写、信封的 `updatedAt` 不动),
  *    行改写是读写两侧同一只封口(`sealStoredCheckpointCtxM28`),封的是「读口会答 `plaintext` 的每一个值」(与开口同一只判词)—— 7.135.0 闭集加了一位
  *    (command 条目的 `plugin.options`)之后,7.134.0 写下的带记号行在那一位上的明文也落在这一条里、同窗补封(本条没有新窗);7.136.0 再加四位(子进程的命令行:MCP stdio 传输与
  *    command 条目各自的 `command` / `args`,第 3 代)同理 —— 无记号行与 7.134.0 / 7.135.0 写下的第 1 / 2 代行上的明文命令行同窗补封。不删行、不改续跑语义;读不出的行计数不动;已封与不带凭据的行零写。读数不进
@@ -271,6 +272,18 @@
  *    迁移段先于起服列册对账,缺列表上的扫描会抛裸的「未知列」、盖住随后的拒启句)。到期 facet 的生成谓词与运维队列行的卡读这一列 —— 本条跑完之前它们不运行
  *    (迁移段先于任何路由与收割器装配)。**够不到的一格(如实登记)**:已决 / 已作废的行不扫(没有读者读它们的卡);local 车道没有这一列(停驻行在引擎自己的 File 店,
  *    卡从文档读)。窗 = 发布日 + 30 天(与 M21 同一条论证:窗关时缺省部署上升级前停驻的行已被终局兜底收走)。
+ *  · **M30 停驻行请求体里的退役键 `promptProfile` 原地改写**(7.137.0,引擎 7.56.0)—— 提示词形收成布尔 `promptLean`,双形词 `promptProfile` 整键退役(新提交在键闭集门 400)。
+ *    7.136.x 及以前停驻的任务,`checkpoint_ctx` 存的请求体带旧键 —— 续跑腿重放它而没有读者 ⇒ `"classic"`(要长形)静默回到模型声明的短形。⇒ **起服扫一遍、原地改写**
+ *    (与 M28 同形同处:不在本文件的迁移段里 —— 那一段跑在 checkpoint 店建成之前;编排在 `stored-request-prompt-profile-m30.ts`,起服第 6 段 M28 之后调一次,
+ *    早于任何路由装配;店腿是两孪生共有的 `rewriteCtxRows`,与 M28 同一只;行改写 = `http/checkpoint-ctx.ts` `rewriteStoredBodyKeys`,只动体的这两个顶层键,
+ *    读法记号与凭据位原样随行)。映射与 MIGRATION 写给调用方的同一张:`"classic"` 且体里没有布尔 `promptLean` ⇒ 删旧键、写 `promptLean: false`;`"simple"` / 词表外 /
+ *    体里已有布尔 `promptLean` ⇒ 只删旧键。已改写与不带旧键的行零写;读不出的行计数不动;续跑时钟不动。读数不进 {@link OneTimeMigrationReport}(`reportKeys` 空,与 M28 同形),
+ *    由起服 info 一行 `checkpoint_ctx_prompt_profile_rewritten` 说(行数,不带值)。窗外不扫。**续跑腿不读旧键**(没有按日历分的第二种读法);存体里仍带它的行
+ *    (窗内从没起过本版的部署;滚动升级里旧副本在本版起服扫描之后才写下的行)由续跑判据响亮拒(`http/stored-body-replay.ts` 第四问,409 `checkpoint.unsupported_version`),
+ *    窗内再起一次本版即被改写。窗 = 发布日 + 30 天(与 M28 / M29 同一条论证:窗关时缺省部署上升级前停驻的行已被终局兜底收走)。**本条不覆盖混跑(如实登记)**:
+ *    ≤7.136.x 的读者只认 `promptProfile`,读到本条改写过的体(旧键已删、换成 `promptLean`)回到缺省形 —— 本版副本起服之后仍在续跑的 7.136.x 副本、回滚到 7.136.x 之后,
+ *    被改写过的 `"classic"` 行静默回短形;也不能给旧读者留旧键(那是同一事实的两份表示,本版读者对仍带旧键的体响亮拒)⇒ 升级序是**先停光 ≤7.136.x 副本、再起第一个 7.137.0 副本**,
+ *    回滚之前先决完或取消停驻的任务(随包 MIGRATION 7.137.0 第 4 条;与 M28 的混跑登记同形)。
  *
  * ## 收据账(一次起服一只,每一条迁移同一只)
  * 每一步把它**已提交**的改写 / 删除与点名读数当场记进同一只收据账({@link MigrationReceipts}):计数随每次提交累加、行随每次提交追加、形读数在那一步落定时写。走完 ⇒
@@ -460,9 +473,15 @@ export declare const ONE_TIME_MIGRATIONS: readonly OneTimeMigrationWindow[];
 /**
  * 一条登记行的窗**此刻**开着没有(`today` = UTC 日历日 YYYY-MM-DD):未发布形(`removableAfter: null`)⇒ 开;否则今天不晚于 `removableAfter` ⇒ 开
  * (窗关当天仍开,与到期门「今天严格晚于才红」同一条边界)。
- * 只给**窗内才生效的行为臂**用(M10 的认领、M19 / M20 的续跑重读):那种臂过了窗就停,不等删码车 —— 删码因此是零行为变化,而窗只写在本表这一处。
+ * 给**窗内才生效的行为臂**(M10 的认领、M19 / M20 的续跑重读)与本文件迁移段之外的起服扫描(M28 / M30)用:过了窗就停,不等删码车 —— 删码因此是零行为变化,而窗只写在本表这一处。
  */
 export declare function migrationWindowOpen(window: Pick<OneTimeMigrationWindow, "removableAfter">, today: string): boolean;
+/**
+ * 一条登记行的窗的**最后一天**(= `removableAfter`,UTC 日历日 YYYY-MM-DD;与 {@link migrationWindowOpen} 同一条边界:这一天仍开)—— 给**要在句子里写绝对日期**的读者读
+ * (续跑拒句「在这一天之前重启即被改写」):窗只写在本表这一处,句子不手写第二份。行不在(读者活过了它的登记行,该随那一行一起删)或未发布形(`removableAfter: null`,
+ * 还没有日期可写)⇒ 响亮抛,不铸一句带空日期的句子。
+ */
+export declare function migrationWindowEnd(id: string): string;
 /** local 车道上 SQL 独有的几条(M8 / M9 / M11 / M17 / M18 / M21 / M23 / M24 / M26 / M27 / M29)的读数(M6 两车道都有,local 腿的读数由 `LocalBackend.runOneTimeMigrations` 现算):那几张表 / 列在文件底座上从来不存在 ⇒ 如实答 absent / 0。 */
 export declare const NO_SQL_MIGRATIONS: Omit<OneTimeMigrationReport, "holderDeathCodeRowsBackfilled">;
 /** 启动期的日志口(logger 的子集)。两级各有其用,见 {@link logOneTimeMigrations}。 */
@@ -520,26 +539,26 @@ export declare function moveWorkflowJournalScope(db: MigrationDb, dialect: "tidb
  * 不是对象 / 没有这两个键 / 条目文字里出现同名字样 ⇒ 空。不改写:新文法写不出旧命令桶的拒(头注 M17 段 ③)。
  */
 export declare function retiredSessionRuleBucketsOf(body: unknown): readonly RetiredSessionRuleBucket[];
-/** M17 —— 一份存量规则体按引擎在它自己的文法里的读法改写成当前文法的同一句话({@link oldGrammarEntriesOf} 的读数)。 */
+/** M17 —— 一份存量规则体按引擎在它自己的文法里的读法改写成文法 1 里的同一句话({@link oldGrammarEntriesOf} 的读数)。 */
 export interface OldGrammarEntries {
     /** toolAllow 里删掉的条目(引擎的 `earlier_grammar` 读数;见 {@link SessionRuleRowOldGrammarEntries.toolAllowDropped})。行因 {@link toolDenyUnreadable} 整行不动时恒空(没写 ⇒ 没删)。 */
     readonly toolAllowDropped: readonly string[];
     /** toolDeny 里引擎 `unreadableDenyEntries` 读成「不是任何一条规则」的条目(条目 + 引擎读者的原因词)。**非空 ⇒ 这一行不改写、不盖戳**({@link rewritten} 缺席):
      *  这种行引擎对每一次工具调用都拒(读成更少的规则是 fail-open,引擎不这么读),并按行自带的旧文法通告;盖成当前文法戳只会让通告消失、行照旧拒一切。缺席 = 没有这样的条目。 */
     readonly toolDenyUnreadable?: readonly UnreadableDenyEntry[];
-    /** 这一行要落的新体 —— 被删条目去掉、其余键原样(退役命令桶也原样)、`grammar: SESSION_RULES_GRAMMAR`;在场 = 要写。缺席 = 零动作:行已带戳且没有可删的条目
+    /** 这一行要落的新体 —— 被删条目去掉、其余键原样(退役命令桶也原样)、`grammar: 1`(本步证过同义的那一版);在场 = 要写。缺席 = 零动作:行已带戳且没有可删的条目
      *  (上一次没走完的判读已改写过的行)。 */
     readonly rewritten?: Record<string, unknown>;
 }
 /**
  * M17 —— 一行存量规则(体 + 它的 `rev`)的改写判读(纯函数,判据只有引擎的):
  *  · 行按引擎的形读法在**它自己的文法**里读 —— `readSessionRulesShape` 对与 `rev` 并排的值按戳读,无戳 ⇒ 文法 0(戳之前写的行);退役命令桶先放一边(形读法拒它们,
- *    而改写的是同一行其余的桶 —— 人按出路删掉退役桶的那一刻,行已是当前文法的真话);
+ *    而改写的是同一行其余的桶 —— 人按出路删掉退役桶的那一刻,行已是文法 1 的真话);
  *  · `toolAllow` 经 `compileSessionRuleBucket` 在那种文法下编译,归 `earlier_grammar` 的条目删掉(文法 0 与 1 在引擎里只差这一条子句:拼写不是它所指名字的 allow 条目
  *    在文法 0 里什么都不放行、在文法 1 里是一条放行规则),名单**保持在场**(在场的空 `toolAllow` 引擎读作「什么都不放行」);别的桶一个字节不动;
  *  · **盖戳前先问引擎读者**([ref]):行的 `toolDeny` 里有 `unreadableDenyEntries` 答的条目(引擎在这一行的文法里读成「不是任何一条规则」)⇒ **整行不改写、不盖戳、不删任何条目**,
  *    条目与读者的原因词随 {@link OldGrammarEntries.toolDenyUnreadable} 交出(收据点名)。引擎对这种行本来就拒一切 —— 本函数只问、不判:不复刻引擎的条目读者,不替运维删条目或改写。
- *  · 新体盖 `grammar: SESSION_RULES_GRAMMAR`:无戳行每一行都写(改写之后部署里零无戳行 —— 除上一条留下的行);已带戳且没有可删条目的行零动作(幂等)。
+ *  · 新体盖 `grammar: 1`({@link M17_PROVEN_GRAMMAR}:本步证过同义的那一版):无戳行每一行都写(改写之后部署里零无戳行 —— 除上一条留下的行);已带戳且没有可删条目的行零动作(幂等)。
  * 读不出形(不是对象、有别的非桶键、桶不是一列字符串、坏戳 / 比引擎新的戳)⇒ `undefined`,不判(读回照旧 `corrupt`)。本函数零处读 / 比较戳的数值:
  * 「有没有戳」是形读法自己判戳之前的同一问;条目在哪种文法下算什么只有引擎读。
  */