@sema-agent/server 7.147.0 → 7.149.0

package/dist/session-error-wire.d.ts

@@ -30,14 +30,14 @@
  *      (同 `placement_kind` 的先例),不在这里解析句子。
  *  · `not_found` —— 留白:每一面各有自己的「不存在」答法(404 `not_found.session` / 同步口的 `resume.session_not_found` /
  *    列表里的缺席),码位各不相同,不由本表统一。
- *  · `placement_refused` —— `import` 面 **409 `conflict.session_placed`**(机读位 `detail.placement_kind`,固定句);`open` 面留白。
+ *  · `placement_refused` —— `import` 面 **409 `conflict.session_placed`**(机读位 `placement_kind`,在拒体根上;固定句);`open` 面留白。
  *    同一个词在两面上说的不是同一件事:import 面只有「会话同步往一只**分区会话**(委派子代的转录)上写」一个来源
  *    (三只持久会话店的整段换装 / 暂存提交门:目标 id 的 `placement_kind` 在场 ⇒ 不适用),调用方没做错格式、是**目标**不收这种写;
  *    open 面上同一个词还含「声明了分区的创建撞上了分区外 / 异组的行」两形(core `TtlSessionStore.assertPlacementAdmission` 的后两条),
  *    那不是「目标是分区会话」。而 run 终局上它是引擎词汇(`terminal.code`),原样随 failed 体走 —— 若在这里分诊成 409,
  *    体上的 `errorCode` 仍是引擎词 `placement_refused`,一个状态两个名字。所以 open 面留白。
  *    409 的语义:目标会话**状态**不收这种写(重试同一个 id 同一结果;换一个会话 id 推)—— 与 `conflict.session_ownerless` / `conflict.session_children_alive` 同族。
- *    `detail.placement_kind` 是**常量**,不是从错误里读的:core 的 `SessionError` 只带 `code` 与句子,不带种类;今天分区种类闭集只有
+ *    `placement_kind` 是**常量**,不是从错误里读的:core 的 `SessionError` 只带 `code` 与句子,不带种类;今天分区种类闭集只有
  *    `"subagent"` 一个词,所以常量就是事实。core 给 `SessionPlacementRecord["kind"]` 加第二个词 ⇒ 下面的守卫编译红,由人裁定种类从哪儿读
  *    (请求 core 把种类放进错误,而不是在这里解析句子)。
  *  · `invalid_entry` / `invalid_fork_target` —— 留白:本仓今天没有一条 wire 口把它们作为自己的
@@ -76,8 +76,8 @@ export interface SessionErrorWire {
      * 点名条目 id / 会话 id / 引擎内部词,wire 上只回一句固定话(各自冻结在 `test/api-error-text-freeze.test.ts` 的常量锚格)。
      */
     readonly sentence?: string;
-    /** 机读事实(体顶层的 `detail` 键;缺席 = 体里不带这个键)。只有 import 面的 `placement_refused` 用它:`{ placement_kind }`。 */
-    readonly detail?: Readonly<Record<string, string>>;
+    /** 机读事实(摊在拒体根上;缺席 = 没有可机读的事实)。只有 import 面的 `placement_refused` 用它:`{ placement_kind }`(键名随 SQL 列)。 */
+    readonly facts?: Readonly<Record<string, string>>;
 }
 /** import 面 `invalid_session` 的固定句(修前 session-sync 暂存导入腿那一行的原文)。 */
 export declare const STAGED_IMPORT_INVALID_SENTENCE = "staged session log failed validation";
@@ -108,7 +108,7 @@ export declare class StampedSessionArchiveError extends SessionError {
  *
  * 码与句子**就是**那只存档故障的(`cause` = 它;码不另铸 —— 只会是 `corrupt_session`,读不出而说不出在不在的 I/O 级故障不换型):
  * 不认识本型的站点看到的与此前逐字相同(`sessionErrorHttp` 按码映射,wire 与运维日志不变)。认识本型的站点 —— 会话读面的属主读
- * (`http/owner-access.ts` 的 `foldOwnerUnreadable`)—— 把它读成「没有这一行」:与对非属主、对不存在的会话同一只 404,原故障进运维日志。
+ * (`http/owner-access.ts` 的 `readOwnerCell`)—— 把它读成「没有这一行」:与对非属主、对不存在的会话同一只 404,原故障进运维日志。
  */
 export declare class SessionOwnerUnreadableError extends SessionError {
     constructor(fault: SessionError);

package/dist/session-error-wire.js

@@ -22,7 +22,7 @@ export class SessionOwnerUnreadableError extends SessionError {
 export const STAMPED_SESSION_ARCHIVE_SENTENCE = "this session's stored archive still carries an owner stamp written by an earlier server version, so it cannot be forked or have its log replaced; nothing was written — delete the session and push it again";
 const CORRUPT_SESSION = { status: 500, errorCode: "corrupt_session" };
 const INVALID_ENTRIES = { status: 422, errorCode: "invalid_entries", sentence: STAGED_IMPORT_INVALID_SENTENCE };
-const SESSION_PLACED = { status: 409, errorCode: "conflict.session_placed", sentence: PLACED_SESSION_SENTENCE, detail: { placement_kind: PLACEMENT_KIND } };
+const SESSION_PLACED = { status: 409, errorCode: "conflict.session_placed", sentence: PLACED_SESSION_SENTENCE, facts: { placement_kind: PLACEMENT_KIND } };
 const STAGED_IMPORT_OWNER_CHANGED = { status: 409, errorCode: "conflict", sentence: STAGED_IMPORT_OWNER_CHANGED_SENTENCE };
 const STAMPED_SESSION_ARCHIVE = { status: 409, errorCode: "conflict.session_archive_stamped", sentence: STAMPED_SESSION_ARCHIVE_SENTENCE };
 export function sessionErrorWireOf(e, face) {

package/dist/session-incarnation.d.ts

@@ -7,7 +7,7 @@
  *
  * ## 规则(全仓唯一处写)
  *  · **铸点只在新建行**:会话店的 `register` / 无 id 创建 / fork / session-sync 的导入新行。已存在的行化身一个字节都不动;
- *    session-sync 的整段换装(replace / staged commit)换的是**同一位住客**的日志,化身沿用 —— 属主却可以被换装重戳为导入者(local 的 M10 认领同理),
+ *    session-sync 的整段换装(replace / staged commit)换的是**同一位住客**的日志,化身沿用 —— 属主却可以被换装重戳为导入者,
  *    所以化身与属主不是同一条律(读法分三种,见下「两读」)。删除随行消失,同 id 重新登记铸新的。
  *  · **两读(住客的三种问法,各读各的格,不混用)**:
  *    K1 **住客自己的记录**(工作区、记忆、空间分区……按「这一位住客」落的东西)只按化身绑 —— 同一位住客的属主换代(推送重戳 / 认领)不换住客,记录照落;
@@ -15,7 +15,7 @@
  *    (`execution-placement.ts` 的 `sameOccupant`,SQL `incarnation = ? AND owner <=> ?` 的对位)—— 读与写之间属主换了一代 ⇒ 不是判过的那一行;
  *    K0 **只问属主的门**(授权门、暂存提交的属主 CAS)只读属主那一格。三种都读会话**行**;local 店的行 = 会话元数据边档那一格(引擎仓里的存档是匿名内容仓,
  *    存档头上的属主不是行事实 —— `plugins/local-session-store.ts` 头注)。
- *  · **值是不透明随机串**(`randomUUID()`,v4:没有时间戳、没有机器信息 —— 刻意不用 uuidv7,那一形带铸造时刻)。只拿来比较。
+ *  · **值是不透明随机串**(铸法只有 core 的 `incarnationCell(undefined)`,v4:没有时间戳、没有机器信息 —— 刻意不用 uuidv7,那一形带铸造时刻)。只拿来比较。
  *  · **一格、一个解码**:住客令牌是会话**行**上的一格 —— SQL `session_meta.incarnation`(两方言)、local 后端的会话元数据边档那一格
  *    (`plugins/local-session-store.ts` 的 `session-incarnations.json`)。行上的值只经 {@link incarnationFromCell} 解码。
  *  · **按 id 读只有一只:core 的 `SessionStore.headOf(id)`**(core 7.55.0 [ref] S2;`{ owner, incarnation, leafId }`,同一行、同一次读 ——
@@ -47,10 +47,11 @@
  *    认领之后唯一写口按那一读的住客定址判一次(化身 ∧ 属主;不在或不是那一位 ⇒ 回滚认领、答既有的 `409 decide.not_parked`);
  *    赎回面(`parked-revive-surface.ts`)只收写口放行的那一位,属主 = 卡的 principal 时交继承座。
  *  · core 的记忆引擎:Runner 读**它取到的那只会话**的 `getMetadata().incarnation`(SQL 两店的 wake 带出这一列;local 店交出的会话
- *    在元数据上答边档那一格),不再有宿主座。
+ *    在元数据上答边档那一格),不再有宿主座。local 数据根上两条入口(HTTP 服务的 local 臂、run-local)经**同一只** local 店打开会话
+ *    (`plugins/store-backend.ts` 的 `openLocalBackend`)⇒ 同一只会话在两条入口上是同一位住客;引擎存档头上另铸的那只令牌不作住客读(只当存档的行代号)。
  *  · 没取会话的那一侧(k8s 工作区空间的分区,`boot/execution-env.ts`):会话店的 `headOf`,经 {@link sessionFaceOfHead} 拿令牌;缓存包装层原样转发。
  */
-import type { SessionHead } from "@sema-agent/core";
+import { type SessionHead, type SessionMetadata } from "@sema-agent/core";
 /** 一位活住客:属主 + 它的令牌(同一行、同一次读;投影自会话店的头,见 {@link sessionFaceOfHead})。 */
 export interface SessionFace {
     /** `null` = 登记为无主的会话。 */
@@ -60,7 +61,10 @@ export interface SessionFace {
 }
 /** 会话店的按 id 读(core `SessionStore.headOf` 的形):`undefined` = 没有这只会话;读抛 = 读故障,不是答案。 */
 export type HeadRead = (sessionId: string) => Promise<SessionHead | undefined>;
-/** 铸一只新化身(铸点见头注,只在新建行)。 */
+/**
+ * 铸一只新化身(铸点见头注,只在新建行)。**铸法只有 core 那一只**:`incarnationCell(undefined)` —— 引擎自带仓的唯一铸点(新行一只随机 v4 串,无时间无机器);
+ * 本仓不再自带第二份铸法。core 的返回型把这一格写作可选(`existing` 非空时可以无令牌),新行永远有 —— 这里只收窄成 `string`,缺了是响亮的不变量破,不补铸。
+ */
 export declare function mintSessionIncarnation(): string;
 /** 日志里点名一只化身时唯一允许的形:前 8 位。完整令牌不进任何日志正文。 */
 export declare function incarnationLogPrefix(incarnation: string): string;
@@ -128,6 +132,11 @@ export declare function sessionFaceOfHead(sessionId: string, head: SessionHead |
  * 一次性迁移 M23(窗内)的回填读的都是这一只返回值。缺席 = 店没有实装 `headOf`(读不出属主 / 住客 / 叶子,调用方各按自己的 fail-closed 臂处置)。
  */
 export declare function headReadOf(store: object | undefined): HeadRead | undefined;
+/**
+ * 删除门(`DELETE /v1/sessions/:id` 的属主门 + 协调器的化身围栏)的头读 —— **只判这一处**:店交了 `deletionHeadOf`(删除已开始、还没收完的那一行也答得出属主与住客;local)⇒ 它;
+ * 否则 ⇒ {@link headReadOf}(删除是一个事务的店,没有删到一半的行)。缺席 = 店没有按 id 读。
+ */
+export declare function deletionHeadReadOf(store: object | undefined): HeadRead | undefined;
 /** 换装沿用的行格(化身 + fork 键):{@link carriedRowCells} 的答案。`forkKey: null` = 没有可沿用的键(新建行 / 行上本来没有)。 */
 export interface CarriedRowCells {
     readonly incarnation: string;
@@ -158,4 +167,42 @@ export declare const SESSION_META_INCARNATION_COLUMN: {
     readonly mysql: "incarnation VARCHAR(64) NOT NULL DEFAULT ''";
     readonly pg: "incarnation VARCHAR(64) COLLATE \"C\" NOT NULL DEFAULT ''";
 };
+/**
+ * SQL 两方言 `session_meta` 的 fork 谱系两列(列定义的唯一属主;两方言建表语句各插一处 —— 与上面的化身列同住:谱系的住客那一半就是源行那一刻的化身;
+ * 谁写、怎么铸见 `plugins/session-fork.ts`「fork 谱系」)。宽度 = 会话 id 列 / 化身列的宽度(两格存的就是这两种值)。
+ * 可空:NULL = 不是 fork 建的行,或谱系落地之前建的 fork(不回填)。存量库缺这两列 ⇒ 起服列册对账拒启,拒句给 ALTER(由本建表语句生成)。
+ */
+export declare const SESSION_META_LINEAGE_COLUMNS: {
+    readonly mysql: "forked_from VARCHAR(64) NULL,\n     forked_from_incarnation VARCHAR(64) NULL";
+    readonly pg: "forked_from VARCHAR(64) COLLATE \"C\",\n     forked_from_incarnation VARCHAR(64) COLLATE \"C\"";
+};
+/**
+ * 行上谱系两格 → 交出的会话元数据的谱系两键(三店的唯一读法:SQL 唤醒读两列、列表读 `forked_from`;local 读那一格的两位)。
+ * 非空串 ⇒ 在;NULL / 缺 / 空串 ⇒ 键缺席(omit-when-absent,恒不铸 `null`)。来源住客读法 = 化身的宽读臂(与头读的住客同一只解码);它是谱系的住客那一半 ——
+ * 没有源 id 就没有谱系,来源住客也不单独交出。
+ */
+export declare function forkLineageOfRow(sessionId: string, forkedFrom: unknown, forkedFromIncarnation: unknown): Pick<SessionMetadata, "forkedFrom" | "forkedFromIncarnation">;
+/** 一次新建行交回的候选:哪只会话、记下的属主、这一次 INSERT 铸的化身(入参里铸的那一只,不是登记之后的复读)。 */
+export interface SessionBirth {
+    readonly sessionId: string;
+    readonly owner: string | null;
+    readonly incarnation: string;
+}
+/** 登记回执:`minted` 只在这一笔真建了新行时在场。 */
+export interface RegisterReceipt {
+    readonly minted?: SessionBirth;
+}
+/** 撤回判下来「留」的店内词(闭集;出口的计数词表在它之上加座内的词,`src/submission-exit.ts`)。`claim` = 这一行被持有:活 run 的认领,或一次删除的在删态(会话三态,`session-deletion.ts`)。 */
+export type StoreKeptWord = "absent" | "incarnation" | "content" | "claim" | "client_writes" | "runs" | "upgrade_pending";
+/** 撤回的结局。 */
+export type WithdrawOutcome = {
+    readonly withdrawn: true;
+} | {
+    readonly withdrawn: false;
+    readonly kept: StoreKeptWord;
+};
+/** 部署判据的答案(店的条件删除在同一事务里问部署):放行(本次 run 的部署行已在同一事务里删掉)或留(部署那一半的哪一条)。 */
+export type WithdrawJudgeVerdict = "proceed" | {
+    readonly keep: Extract<StoreKeptWord, "client_writes" | "runs" | "upgrade_pending">;
+};
 //# sourceMappingURL=session-incarnation.d.ts.map

package/dist/session-incarnation.js

@@ -1,6 +1,9 @@
-import { randomUUID } from "node:crypto";
+import { incarnationCell } from "@sema-agent/core";
 export function mintSessionIncarnation() {
-    return randomUUID();
+    const { incarnation } = incarnationCell(undefined);
+    if (incarnation === undefined)
+        throw new Error("core's incarnationCell(undefined) minted no token for a new row — refusing to invent one");
+    return incarnation;
 }
 export function incarnationLogPrefix(incarnation) {
     return incarnation.slice(0, 8);
@@ -67,6 +70,10 @@ export function headReadOf(store) {
     const read = store?.headOf;
     return typeof read === "function" ? read.bind(store) : undefined;
 }
+export function deletionHeadReadOf(store) {
+    const read = store?.deletionHeadOf;
+    return typeof read === "function" ? read.bind(store) : headReadOf(store);
+}
 export function carriedRowCells(sessionId, prior) {
     const held = prior === undefined ? undefined : incarnationFromCell(sessionId, prior.incarnation, "absent");
     if (held === undefined)
@@ -78,4 +85,14 @@ export const SESSION_META_INCARNATION_COLUMN = {
     mysql: "incarnation VARCHAR(64) NOT NULL DEFAULT ''",
     pg: `incarnation VARCHAR(64) COLLATE "C" NOT NULL DEFAULT ''`,
 };
+export const SESSION_META_LINEAGE_COLUMNS = {
+    mysql: "forked_from VARCHAR(64) NULL,\n     forked_from_incarnation VARCHAR(64) NULL",
+    pg: `forked_from VARCHAR(64) COLLATE "C",\n     forked_from_incarnation VARCHAR(64) COLLATE "C"`,
+};
+export function forkLineageOfRow(sessionId, forkedFrom, forkedFromIncarnation) {
+    if (typeof forkedFrom !== "string" || forkedFrom === "")
+        return {};
+    const occupant = incarnationFromCell(sessionId, forkedFromIncarnation, "absent");
+    return { forkedFrom, ...(occupant !== undefined ? { forkedFromIncarnation: occupant } : {}) };
+}
 //# sourceMappingURL=session-incarnation.js.map

package/dist/session-policy-wire.d.ts

@@ -21,7 +21,7 @@
  *  · 本仓自己的形读者、桶表与逐键问引擎的那一圈(同一问的第二个读者,[ref])⇒ 读回直接读引擎的形读法。
  */
 import { SessionPolicyError } from "@sema-agent/core";
-import type { SessionPermissionRules, SessionRuleEntryRefusal, SessionRuleShapeRefusal, SessionRulesRecord } from "@sema-agent/core";
+import type { SessionPermissionRules, SessionRuleEntryRefusal, SessionRulesRecord } from "@sema-agent/core";
 /** 引擎的两只**内容**拒(规则体自己的问题;`conflict` / `loosen_forbidden` / `corrupt` 是店与这一次写的关系,不在此列)。 */
 export type SessionRulesRefusal = SessionPolicyError & {
     readonly code: "invalid_shape" | "inert_entry";
@@ -120,8 +120,11 @@ export declare function describeInertEntry(r: SessionRuleEntryRefusal): string;
  * 引擎契约破了(`inert_entry` 不带条目读数)⇒ 抛,不编一句。
  */
 export declare function sessionPolicyErrorSentence(e: SessionPolicyError): string;
-/** 一只 `SessionPolicyError` 上 wire 的拒体格(引擎的 `detail` 原样摊在体顶层;只在两只内容码上有)。 */
-export declare function sessionPolicyErrorFacts(e: SessionPolicyError): Readonly<SessionRuleShapeRefusal | SessionRuleEntryRefusal> | undefined;
+/**
+ * 一只 `SessionPolicyError` 上 wire 的拒体事实(只在两只内容码上有):引擎的 `detail` 经**闭集映射**进拒体根(对位 `http/refusal-body.ts` 的 `resumeRefusalFacts`)——
+ * 按码取那一张键表,逐键过境、值原样;表外的键(引擎多带的成员、句子专用的 `carriedBy`)不过境,值为 `undefined` 的键不铸。
+ */
+export declare function sessionPolicyErrorFacts(e: SessionPolicyError): Readonly<Record<string, unknown>> | undefined;
 /**
  * 🔴 **`SessionPolicyError` 的闭集 → HTTP 的**唯一**映射(core 7.25.0 提货批新建)。**
  *

package/dist/session-policy-wire.js

@@ -107,8 +107,18 @@ export function sessionPolicyErrorSentence(e) {
         throw new Error(`SessionPolicyError inert_entry without the entry reader's detail: ${e.message}`);
     return describeInertEntry(e.detail);
 }
+const SHAPE_REFUSAL_FACT_KEYS = ["field", "got"];
+const ENTRY_REFUSAL_FACT_KEYS = ["field", "entry", "reason", "verdict", "guidance", "currentName", "ambiguous", "valueType"];
 export function sessionPolicyErrorFacts(e) {
-    return isSessionRulesRefusal(e) ? e.detail : undefined;
+    if (!isSessionRulesRefusal(e) || e.detail === undefined)
+        return undefined;
+    const detail = { ...e.detail };
+    const keys = e.code === "invalid_shape" ? SHAPE_REFUSAL_FACT_KEYS : ENTRY_REFUSAL_FACT_KEYS;
+    const facts = {};
+    for (const key of keys)
+        if (detail[key] !== undefined)
+            facts[key] = detail[key];
+    return facts;
 }
 export function sessionPolicyErrorHttp(code) {
     switch (code) {

package/dist/session-resident-background.d.ts

@@ -1,74 +1,3 @@
-/**
- * `/health.inflight` 计法表里**会话驻留的后台行**两类 —— 后台子代理(`backgroundAgents`,进阻断集)与后台 shell / monitor(`sessionResident`,只进总数)。
- *
- * ## 病
- * 引擎在飞数原先只数 HTTP 腿与 leader 腿。模型在会话里起的后台活 —— `run_in_background` 的 shell / monitor、core `backgroundScope:"session"` 下的
- * 后台子代理(Agent / Fork)—— 活过起它的那一条腿:腿一收,三张登记簿里都没有它,而引擎还托管着它。读 `/health` 判「这台引擎是否空闲」的外部判官看不见它们,
- * 只好另拼一条谓词(同一个事实两个读法);附着租约 / 排空 / SIGHUP 空闲窗对还在烧模型的后台子代理同样看不见,把它随引擎的受控退中断。
- *
- * ## 两个事实(本文件产分项里的两项;两个和只在 `fleet/drain-entry.ts` 各写一次)
- * `/health.inflight`(总数,{@link inflightTotal})= 引擎此刻托管着多少活 = `http + leader + backgroundAgents + sessionResident`,可观测事实;
- * `drainState.blockingInflight`(阻断集,{@link blockingInflightOf})= 还有没有必须等完的活 = `http + leader + backgroundAgents`,排空 / 孤儿窗 / 附着租约自退 / SIGHUP 空闲窗判停读它。
- * 两个和读**同一只**分项函数(`http/server.ts` 的 `inflightBreakdown`),本文件的读数在一次走查里同时交出两项 —— 判停与 `/health` 不是两份算法。
- *  · `backgroundAgents` **进阻断集**:后台子代理是一条在干活的模型腿,干完自己收尾(在审批 / 问答卡上等人时行仍是 `running`、照计;窗满转成耐久停驻后不再计);
- *    不等它 = 受控退把一条还在干活的子代理中断(账本行落终态,模型工作丢)。与驻留 shell 的分界不是「有没有墙钟上限」—— core [ref] 已退役会话级子代理的
- *    30 min 缺省墙钟,两类都没有 —— 而是「会不会自己结束」:模型腿干完即止,`while true` 的 shell 永不。
- *    上界 = 停滞收割窗 `BG_AGENT_STALL_MS`(下面「停滞收割」一节):任务表行一直是 `running`、却不再有工具活动的子代理 —— 挂死的,或已收尾、但 core 在把行转终态之前
- *    await 的那一次委派行写 / 工作树收尾挂住了的(core `agents/subagent.js` 子代收尾链:`await rowSettled` 先于 `settleBackgroundAgent`)—— 静默满窗即被收,不再无界地撑着判停窗。
- *  · `sessionResident` **只进总数**:驻留 shell 不是一条腿,等它没有意义;一只不退出的 shell(`while true`)若阻断,崩溃孤儿引擎就永生、排空每次等满窗。
- *    窗到 / 排空完成,退出边界的后台收割收掉它们,retain 行按 retain 既有语义活过受控退。
- *
- * ## 读法(本文件是唯一属主;行判一处写:{@link sessionResidentTermOf})
- * 行集 = core `TaskRegistry.liveTasks(access)` 的投影,按行类型与状态分到两项之一或不计:
- *
- *  | 行(`sessionScoped` 为真)                         | 状态 `pending` / `running` | `parked`          | 终态 |
- *  |---------------------------------------------------|----------------------------|-------------------|------|
- *  | `background_agent`(后台子代理)                   | `backgroundAgents`         | 不计(耐久停驻) | 不计 |
- *  | `background_bash` / `monitor`,非 retain          | `sessionResident`          | 不计              | 不计 |
- *  | `background_bash` / `monitor`,retain             | 不计(交付的活服务,活过受控退)                 |||
- *  | `workflow`                                        | 不计(见下)                                     |||
- *
- *  · **`sessionScoped` 为假的行不计**:挂在 run 腿上的后台行随腿登记在 `http` 项里,数它是第二次(腿一收,core 的拆腿收割把它们一起结掉)。
- *  · **`parked` 不计**:与停驻的 run 同一条律 —— 停驻是耐久的(引擎退了不丢,下次起来仍可赎回),不占执行座;算它,一张没人答的审批就让引擎永远退不掉。
- *  · **`workflow` 行不计**(计法表成文的一行,不是遗漏):任务表对一条 workflow 只投 `running`,一条腿停在审批门上等人时也还是 `running` ——
- *    这只读法分不出「在干活」与「在等人」。进阻断集 ⇒ 一张没人答的审批让崩溃孤儿引擎永生(与驻留 shell 同一病);只进总数 ⇒ 多一类只报不阻断的项、
- *    判据与停驻律对不上。停驻位(core `runParkedOf`)要由任务表投出来才能按停驻律分(请托 core);到货前 workflow 照旧不进在飞,与 7.146.x 同。
- *  · **状态是闭集**(`SemaTaskStatus` 穷举):core 加一个词 ⇒ 这里编译红,不会被静默读成「不计」。
- *  · **一行只数一次**:各会话的可见集可以相交(core `canAccess` 对后台子代理还认 `rootSessionId` —— 子会话与根会话都在围栏表时,两次读都看得见同一行)⇒ 整趟走查按 `task_id` 去重。
- *  · **选座 `liveTasks`,不读 `list()`**:`list()` 是显示投影,硬帽 500 行(core 注:resolution must NEVER ride the display-capped list());
- *    超过 500 行时 `list()` 会静默少数,方向恰是「以为空闲」。`liveTasks` 无显示帽。
- *
- * ## 枚举源
- * core 的 `canAccess` 要求访问元组带 `scope`(缺 scope 一律拒),`list` / `liveTasks` 因此只读「调用方可达行」,没有进程总数的读口。
- * 进程级的数由本仓自己枚举「本进程有哪些会话」:枚举源 = **围栏表**(`boot/execution-env.ts` 的 `SessionScopedRegistries.sessionOwners`):
- * 每次提交经 resolve-spec 写一笔(会话 id → 属主),删会话的 E21 级联清一笔,LRU 有界。scope 轴 = {@link sessionChildrenScope}(会话属主 `?? "default"`,
- * 删除门 / 换绑门 / 结清口 / 会话后台读面同一个取法,不另取)。会话驻留的后台子代理 `owner` = 会话 id([ref] 纪律),同一只访问元组够得着。
- * 〔待 core:一只进程级、不按访问元组收窄的计数读口(`countRunningBackgroundShells` 的子代理孪生)到货后,子代理一项改读它 —— 下面三条边界随之消失。〕
- *
- * ## 读到的边界(成文,不静默)
- *  · 围栏表是 LRU(上界 4096 会话):被挤出表的会话,它的会话驻留行在这里不可见 —— 回到 7.146.x 前的读数(不是新的错),不会多数;
- *  · 不经 resolve-spec 的内部车道(服务为自己起的 run)不写围栏表,它们起的会话驻留行同样不可见;
- *  · 删会话的级联在 `dropSessionScoped` 之后、后台收割之前失败(会话行因此没删)时,围栏表已先清:该会话还在跑的驻留行在下一次提交重新围栏之前不可见
- *    (修法是把 `dropSession` 的「清秘密」与「忘身份」拆开,属围栏表的属主,不在本读法里);
- *  · 每次读是 O(围栏表会话数 × 注册表行数)(`liveTasks` 逐会话走一遍注册表);表的上界 4096、注册表行数小,量级是毫秒。
- *    这一读在判停路径上(排空 1 s 拍 / 租约拍 / SIGHUP 拍)每拍付一次 —— 后台子代理进阻断集的代价,与 `/health` 同一份。
- *
- * ## 停滞收割:先收尸,再数活(本文件是收割的唯一调用点)
- * 引擎把会话驻留后台子代理的反僵尸义务交给调用方:`TaskRegistry.reapStaleSessionBackgroundAgents(staleMs)` 把**最后一次工具活动**距今超过 `staleMs` 的
- * `running` 行收成 `killed`(归因 `system`,措辞与耐久 stale-running 清扫同一句)并中止它的 run;停驻行、随腿的行、终态行它不碰。
- * {@link countSessionResidentBackground} 每读一次先调它一次、再走任务表 —— 所以计法表里「在跑的后台子代理」= 引擎任务表此刻说 `running` 的行,
- * 而任务表在被数之前已经按停滞窗结清过一遍。本服务不另判「这一行其实不活」(行说 running、本服务说不活 = 一个事实两种读法):不活的行由引擎收成终态,本文件只数。
- *  · **拍**:不另起计时器。读口的读者就是拍 —— 排空 1 s 拍、附着租约拍、SIGHUP 空闲窗 1 s 拍、`/health`、崩溃遗言;每一处判停读数之前都先收过一次。
- *    没有任何读者的进程里没有判据要读这一项,僵尸行只停在任务表的显示面上。
- *  · **窗**:`BG_AGENT_STALL_MS`,缺省 = 下限 = 派生值(`config.ts` 的 `backgroundAgentStallFloorMs`:等人的四个窗取大 + 引擎单命令上限)。
- *    子代在审批卡 / 问答卡上等人时行是 `running`、没有工具活动 —— 窗不盖住等人的窗,就会把一只等你回来批的子代当僵尸收掉。
- *  · **收割失败**(引擎抛)⇒ 读口照数任务表(没收掉的行照算在跑:宁可等,与收割接线之前同读)并经 `stall.report` 报出;读口不抛。
- *
- * ## 读不出 ⇒ 非空闲(响亮,不替成 0)
- * 本函数在判停路径(排空首读在期限计时器装上之前)、`/health` 应答与崩溃遗言里被调,**不许抛**(判停首读一抛 ⇒ 期限计时器装不上 ⇒ 永不硬停;
- * 崩溃遗言里一抛会吞掉遗言本身)。某个会话的读失败(含行判遇到闭集外的值)⇒ 该会话按 **1 只在跑的后台子代理**计 —— 落在阻断项里,判停也看得见
- * (读不出 ⇒ 非空闲:宁可当有活)—— 并经 `onUnreadable` 报出;调用方必须给报口(装配层一会话一行 `session_resident_background_unreadable`),不存在静默的 0。
- */
 import { type TaskListRow, type TaskRegistry } from "@sema-agent/core";
 import type { InflightBreakdown } from "./fleet/drain-entry.js";
 /** 枚举源的形:会话 id → 会话属主(`null` = 匿名)。`Map` 满足它。 */

package/dist/session-resident-background.js

@@ -1,5 +1,6 @@
+import { writeLogText } from "./observability/logger.js";
 import { defaultTaskRegistry } from "@sema-agent/core";
-import { sessionChildrenScope } from "./session-children-retire.js";
+import { sessionTenantScope } from "./session-children-retire.js";
 function liveStatus(status) {
     switch (status) {
         case "pending":
@@ -43,7 +44,7 @@ export function countSessionResidentBackground(sessions, opts) {
     for (const [sessionId, owner] of sessions) {
         try {
             const fresh = [];
-            for (const row of registry.liveTasks({ owner: sessionId, sessionId, scope: sessionChildrenScope(owner) })) {
+            for (const row of registry.liveTasks({ owner: sessionId, sessionId, scope: sessionTenantScope(owner) })) {
                 const term = sessionResidentTermOf(row);
                 if (term !== undefined && !counted.has(row.task_id))
                     fresh.push([row.task_id, term]);
@@ -82,7 +83,7 @@ function reportSafely(fallbackLine, report) {
         report();
     }
     catch (reportErr) {
-        console.error(...fallbackLine, reportErr);
+        writeLogText("stderr", ...fallbackLine, reportErr);
     }
 }
 //# sourceMappingURL=session-resident-background.js.map

package/dist/session-row.d.ts

@@ -56,7 +56,8 @@ export interface ReplaySessionRowWrite {
 export type SessionRowWrite = ClientSessionRowWrite | ReplaySessionRowWrite;
 /**
  * 写原语的结局(闭集四员):`written` / `changed` 带提交(回滚)之后另读的那一行(列表行投影,含新 `rowTag`);`mirror`(客户端写在只读镜像上)/
- * `absent`(行期望不中 / 没有行 / 委派分区行 / 应答行已不是判过的那一位住客)一个字节没写。
+ * `absent`(行期望不中 / 没有行 / 委派分区行:锁下拒,一个字节没写;或应答行复核已不是判过的那一位住客:判官答 `changed`、回滚之后换人 = 零写,答 `write`、已提交之后换人〔SQL 后端才有这一窗〕= 写已落,
+ * 随旧行的外键级联删掉,或留在已换主的行上 —— 三分见 `plugins/session-row-sql.ts` 头注「结局 `absent` 的三种去向」)。
  */
 export type SessionRowWriteOutcome<Row> = {
     readonly kind: "written";

package/dist/session-rules-seat.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 🔴 **会话规则的引擎席**(场景子命名空间):会话规则桶的键 = (会话号, **会话属主**)—— 会话号定分区,会话行的属主是那一格分区的主体
+ * (路由 `GET/PUT /v1/sessions/:id/policy` 按会话属主写,`http/routes/sessions.ts`)。引擎读写会话规则时交的是 `spec.principal` = **人**
+ * (引擎交界的身份格,`engine-identity.ts`):带场景的会话,人 ≠ 属主,原样查 = 落到另一只桶(运维在 health 会话上 PUT 的 deny 对引擎不存在 = 安全轴放宽)。
+ *
+ * 律(一句):引擎交来的人恰是这只会话属主背后的人 ⇒ 键换成会话属主;否则原样(与今天逐字节同 —— 没带场景的会话属主与人字节相同,两种读法同一个键)。
+ * 属主只经会话店的头读一处(`headOf(id)?.owner`,会话行是属主的唯一事实);读不到头(会话不在 / 店不交头读)⇒ 原样。读写两腿与祖先会话的规则读同经这一只席。
+ */
+import type { SessionPolicyStore } from "@sema-agent/core";
+import type { HeadRead } from "./session-incarnation.js";
+export declare function createEngineSessionRulesSeat(store: SessionPolicyStore, headOf: HeadRead | undefined): SessionPolicyStore;
+//# sourceMappingURL=session-rules-seat.d.ts.map

package/dist/session-rules-seat.js

@@ -0,0 +1,19 @@
+import { personOf } from "./owner-brands.js";
+import { recoveredSubject } from "./owner-faces.js";
+export function createEngineSessionRulesSeat(store, headOf) {
+    const keyFor = async (sessionId, principal) => {
+        if (principal === undefined || headOf === undefined)
+            return principal;
+        const owner = (await headOf(sessionId))?.owner;
+        if (owner === undefined || owner === null)
+            return principal;
+        return personOf(recoveredSubject(owner)) === principal ? owner : principal;
+    };
+    return {
+        getRules: async (sessionId, principal) => store.getRules(sessionId, await keyFor(sessionId, principal)),
+        putRules: async (sessionId, principal, rules, opts) => store.putRules(sessionId, await keyFor(sessionId, principal), rules, opts),
+        ...(store.listBySession !== undefined ? { listBySession: store.listBySession.bind(store) } : {}),
+        ...(store.deleteBySession !== undefined ? { deleteBySession: store.deleteBySession.bind(store) } : {}),
+    };
+}
+//# sourceMappingURL=session-rules-seat.js.map

package/dist/session-titler.d.ts

@@ -11,7 +11,9 @@
  * "Has it a title?" is read from the column on every submit (one point read) — the process keeps NO "already titled"
  * memo, because such a memo would be a second answer to that question that a clear turns stale. Generation = one
  * cheap-model one-liner via the deployment's hookLlm face (summarize role → MODEL_CHEAP_ID when configured, else the
- * main model; bounded + timed out).
+ * main model; bounded + timed out), asked at the LOWEST REASONING SEAT (`reasoningSeat: "lowest"`: a one-line title is
+ * not worth a thinking pass — thinking off where the model's wire can spell it, `low` where it cannot; the keys come from
+ * core's one dialect table and the output cap is sized for the answer plus that tier's thinking, both owned by the llm face).
  *
  * WRITE-AFTER NOTICE: the title that lands is announced to the run that triggered it — `maybeTitle`'s `onTitled` hands the
  * seat (`run-acceptance.ts`) the one `session_titled` frame (`session-titled-frame.ts`, contract §4a-ttl) built from the
@@ -24,7 +26,7 @@
  * session; the store's IS NULL guard closes the cross-replica race (double generation costs one extra cheap
  * call at worst, and exactly one title lands).
  */
-import type { HookLlmFailureCode } from "./hooks/hook-runner.js";
+import type { HookLlmCall } from "./hooks/hook-runner.js";
 import { type SessionTitledFrame } from "./session-titled-frame.js";
 export interface SessionTitlerDeps {
     /** Write-once store leg (SQL twins / local sidecar). Resolves false when a title already existed. */
@@ -35,19 +37,9 @@ export interface SessionTitlerDeps {
      *  and if still absent, release the seen slot so the NEXT submit retries (never a permanently-untitled
      *  session via a swallowed early UPDATE-0). Local lane has no row-existence dimension → never "none". */
     probeTitle(sessionId: string): Promise<"none" | "untitled" | "titled">;
-    /** The deployment's cheap one-shot LLM face (main.ts hookLlm — summarize role default). */
-    llm(opts: {
-        prompt: string;
-        timeoutMs: number;
-        model?: string;
-    }): Promise<{
-        ok: true;
-        text: string;
-    } | {
-        ok: false;
-        error: string;
-        code?: HookLlmFailureCode;
-    }>;
+    /** The deployment's cheap one-shot LLM face (main.ts hookLlm — summarize role default). The face's own type, not a
+     *  second spelling of it: the titler declares its reasoning seat (`reasoningSeat`) on this call and the face honors it. */
+    llm: HookLlmCall;
     logger?: {
         debug?(msg: string, meta?: unknown): void;
         info?(msg: string, meta?: unknown): void;

package/dist/session-titler.js

@@ -79,7 +79,7 @@ export function createSessionTitler(deps) {
                     deps.metrics?.inc("session_title_total", { outcome: "already_titled" });
                     return;
                 }
-                const r = await deps.llm({ prompt: buildTitlePrompt(objective), timeoutMs: LLM_TIMEOUT_MS, model });
+                const r = await deps.llm({ prompt: buildTitlePrompt(objective), timeoutMs: LLM_TIMEOUT_MS, model, reasoningSeat: "lowest" });
                 if (!r.ok) {
                     deps.metrics?.inc("session_title_total", { outcome: "llm_failed" });
                     logFailure(sessionId, r.error, r.code);

package/dist/session-workspace.d.ts

@@ -23,9 +23,9 @@
  * 会话在没有记号的检出里续跑时,项目随每一次不带 `projectId` 的提交丢掉。现在:一个值进引擎、一格存引擎的答案、下一条腿读那一格。
  *
  * ## 不在这里的(如实)
- *  · **记忆项目层**(单用户 `userrepo:` 键,`project-identity.ts` 的 git 检出身份)不是这个事实:它在装配期(任何帧之前)交给
- *    `TaskSpec.memory.projectKey`,按 git 仓库(origin 远端 / 本机路径)键控,与 `.sema/project` 记号无关;引擎 7.58.0 自己也写明
- *    「只声明的身份不改记忆的键」。两者是否该合成一个身份,是另一张设计票。
+ *  · **记忆项目层**(单用户 `userrepo:` 键,`project-identity.ts`)不读这一格:它在装配期(任何帧之前)交给 `TaskSpec.memory.projectKey`,
+ *    身份是**检出**的函数 —— 检出带 `.sema/project` 记号 ⇒ 按记号键控,读法就是引擎判官读的同一只(core `resolveProjectId`,同一任务根);
+ *    没有记号 ⇒ git 根回落。行上 `source: "declared"` 的项目不改项目层的键(引擎 7.58.0 记忆自己的读法同:「只声明的身份不改记忆的键」)。
  *  · 多租户记忆分区(`proj:<租户>/<projectId>`)与登记簿种子读的是**这次提交**的 `projectId`(按提交挑盘,修前即如此),不读行。
  *  · 行上的项目还有一位读者:会话视图 `GET /v1/sessions/:id` 体顶层的 `projectId`(唯一读口 {@link readSessionProjectId},与视图的 `agent` 同一次视图读)。
  *    `root` / `cwd` / `entered` / `remote` 今天只存不读;fork 出的新会话从「没有记录」起(项目声明按引擎契约每腿都带,fork 的首腿由调用方带上)。

package/dist/spec-fields.d.ts

@@ -78,12 +78,60 @@ export declare const MAX_TASK_AGENTS = 32;
  * `ruleEntryListShapeOk`):引擎直接 `for (const entry of list)` —— 一个裸字符串 `"Bash"` 会被逐字符迭代成 `B` / `a` / `s` / `h` 四条
  * (deny 侧 = 意图静默落空,安全轴上的放宽方向)。条目的**文法与名字**是引擎的读法:允侧读不出的条目(`*` / 写路径 / 域名 / 退役名 …)引擎在开跑时发
  * `permission.allowed_tool_not_granted`(受众 = 用户);拒侧读成空的条目(文法或名字层)在 `resolveSpec` 拒(提交 400 / 续跑 409,`rule-entry-list.ts` 的
- * `inertToolListEntryOf`,判据 = 引擎的条目读法;同一只函数也拒请求的工具名选择器清单里的近似名 / 退役名)。
+ * `inertToolListEntryOf`,判据 = 引擎的条目读法;同一只函数也拒请求的工具名选择器清单里的近似名 / 有后继的退役名;限制侧**没有后继**的退役名 core 7.66.0 起不拒,引擎保留这一行并发 `config.legacy_tool_name`)。
  * **条数帽**是全部工具名清单的同一只判(`rule-entry-list.ts` 的 `skillToolListsOverCap`;句子与机读位 `field` 点体内坐标 `skills[1].allowedTools` /
  * `agents[0].skills[2].disallowedTools`):顶层 `validateUserSkills` 与子代 {@link validateTaskAgents} 两道门都逐条先形、后帽(与 7.131.0 的拒点与判序同);
  * 拒点 `resolveSpec` 两腿同经的 `inertToolListEntryOf` 先过同一只判;无长度帽([ref])。
  */
 export declare const skillToolListOk: (v: unknown) => v is readonly string[];
+/**
+ * = core `SKILL_CONTENT_MAX_CHARS`(1 MiB 加载门;core 1.293 起 invoke 全文零截断、超 1 MiB 整拒;常量在 `dist/core/runner/synthetic-tools.js`,
+ * 未从 core 包根导出,故钉本地孪生 + 本出处注记)。两道技能门(顶层 `body.skills[i]` 与子代 `agents[a].skills[j]`)读这**一只**:同值两名就是第二个会漂的域。
+ * 🔴 这是技能面**唯一**剩下的尺寸门,而且它不是超集帽:引擎在装配期对超 1 MiB 的技能本就整拒,门上先答只是把同一个判决搬到调用方看得懂的地方
+ * ([ref] 退役的三条帽 —— 条数 / description / name 长度 —— 都没有这个性质)。
+ */
+export declare const MAX_SKILL_CONTENT_CHARS = 1048576;
+/**
+ * 请求面技能上**有名而不收**的键:每只一句句尾,两道门同字节(拒句 = 体内坐标 + 句尾)。本表只给**话**;键在不在由 {@link namedRefusalOf} 答。
+ *  · `manifest` —— core 7.41.0 [ref] 退役(硬破坏,零别名);出路只点本服务上真存在的旋钮:两只清单、deny 规则 / 子代 `allowTools`、会话规则 `allowDirs`。
+ *    任何值都拒(`null` / 空对象同样是「我带了 manifest」),不翻译成 `allowedTools`(那是放宽方向);
+ *  · `mods` —— core 7.56.0 [ref] 的技能座扩展注册(带 `register` 函数的代码对象),不是请求数据(JSON 带不过函数);任何值都拒。
+ */
+export declare const SKILL_NAMED_REFUSALS: {
+    readonly manifest: "was retired in core 7.41.0 — a skill's tools are its allowedTools / disallowedTools now (an allow-rule and a deny-rule source for the run the skill is activated in, never a fence); move manifest.allowTools to allowedTools. To fence tools use deny rules (settings.permissions.deny) or a delegated agent's allowTools; to fence write paths use the session rules' allowDirs";
+    readonly mods: "is not a request key — skill registrations are code the deployment mounts, not request data (this server does not compile skill hooks: GET /v1/capabilities answers mods.skill_seat: false)";
+};
+/** 一键的撞帽读数(形对、只是超了帽;量纲 / 送来的量 / 帽)。形错不是撞帽 —— 那一形只有句子。 */
+interface SkillFieldLimit {
+    readonly measure: LimitMeasure;
+    readonly count: number;
+    readonly cap: number;
+}
+/**
+ * 一条技能的问题 —— **数据,不带坐标**:`key` = 出问题的那一键(缺席 = 这条技能本身不是对象)、`words` = 这一键的话(句尾)、撞帽另带读数。
+ * 坐标由调用方给({@link skillRefusalAt} 一处铸句子与机读位),所以两道门的句尾逐字节同。
+ */
+export interface SkillItemIssue {
+    readonly key?: string;
+    readonly words: string;
+    readonly limit?: SkillFieldLimit;
+}
+/**
+ * **一条技能的唯一判官**(顶层 `validateUserSkills` 与子代 {@link taskAgentIssue} 都只调它):合形 ⇒ `null`;否则第一处问题({@link SkillItemIssue})。
+ * 判序:不是对象 ⇒ 整条;点名拒的两只({@link namedRefusalOf})→ 键序逐键过闭集(未知键);再按键表序判必填与形(撞帽的形对键带读数)。
+ * 键判断用 `Object.hasOwn`:`in` 走原型链,JSON 里的 "toString" / "constructor" 键会被误判成白名单字段(与 {@link taskAgentIssue} 同一条教训)。
+ * 调用方写的键名过唯一回显口径(有界、剥控制 / 双向字符)再进句子与坐标。
+ */
+export declare function skillItemIssue(skill: unknown): SkillItemIssue | null;
+/** 一条技能的拒(两道门同形):句子 = `<坐标> <这一键的话>`;机读位 `field` = 那一键的体内坐标,撞帽另带 `reason` / `count` / `cap`。 */
+export interface SkillItemRefusal {
+    readonly message: string;
+    readonly facts: {
+        readonly field: string;
+    } | LimitFacts;
+}
+/** 把 {@link skillItemIssue} 的问题铸成坐标 `at`(`skills[0]` / `agents[1].skills[2]`)上的拒 —— 句子与机读位的唯一铸点。 */
+export declare function skillRefusalAt(at: string, issue: SkillItemIssue): SkillItemRefusal;
 /**
  * 一条子代定义的裁决:`message` = 一句可 400 的英文(不带下标,调用方加);撞帽时另带 `limit`(`rel` = 相对这条定义的坐标 `allowTools[3]` / `name`),
  * 句子是撞帽的头一句(`agent.allowTools[3] has 129 characters — at most 128 are accepted`:撞了哪一条帽、送来多少、帽多少),
@@ -97,11 +145,16 @@ export interface TaskAgentIssue {
         readonly count: number;
         readonly cap: number;
     };
+    /** 问题在这条定义的第 `index` 条技能上(技能判官的问题,不带坐标)—— {@link validateTaskAgents} 以体内坐标 `agents[i].skills[index]` 铸拒({@link skillRefusalAt})。 */
+    readonly skill?: {
+        readonly index: number;
+        readonly issue: SkillItemIssue;
+    };
 }
-/** 提交体 `agents` 的拒:句子(带下标)+ 撞帽时的机读位(`field` / `reason` / `count` / `cap`,`limit-refusal.ts` 一处铸)。 */
+/** 提交体 `agents` 的拒:句子(带下标)+ 机读位(撞帽:`field` / `reason` / `count` / `cap`,`limit-refusal.ts` 一处铸;技能那一层的每一只拒带 `field`,{@link skillRefusalAt})。 */
 export interface TaskAgentsRefusal {
     readonly message: string;
-    readonly facts?: LimitFacts;
+    readonly facts?: SkillItemRefusal["facts"];
 }
 /** [ref] 单条 agent 定义的形状裁决:null=合法;否则一句可 400 的英文错误(不带索引,调用方自己加)。
  *  白名单外键 fail-loud —— 与 resilience/limits 的「容忍未知键」相反:agents 是能力定义,静默丢字段 =
@@ -262,4 +315,5 @@ export declare function normalizeApproachNotice(raw: unknown): false | {
  * 全空 ⇒ undefined(spec 不挂 limits 键,byte-compat)。
  */
 export declare function resolveTaskLimits(bodyLimits: unknown, caps: TaskLimitCaps, envTimeoutSec: number, requirePrincipal: boolean | undefined, warn?: (event: string, fields: Record<string, unknown>) => void): TaskSpec["limits"];
+export {};
 //# sourceMappingURL=spec-fields.d.ts.map