@sema-agent/server 7.146.0 → 7.148.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,57 +1,39 @@
-/**
- * `/health.inflight` 计法表第四类 —— **会话驻留的后台 shell / monitor**。
- *
- * ## 病
- * 引擎在飞数原先只数 HTTP 腿与 leader 腿。模型在会话里起的后台 shell / monitor(`run_in_background`)活过起它的那一条腿 —— 腿一收,它在这份数里是 0:
- * 读 `/health` 判「这台引擎是否空闲」的外部判官看不见它们,只好另拼一条谓词 —— 同一个事实两个读法。
- *
- * ## 两个事实(本文件只产总数里的第三项 `sessionResident`)
- * `/health.inflight`(总数,{@link inflightTotal})= 引擎此刻托管着多少活 = `http + leader + sessionResident`,可观测事实;
- * `drainState.blockingInflight`(阻断集,{@link blockingInflightOf})= 还有没有必须等完的活 = `http + leader`,排空 / 孤儿窗 / 附着租约自退 / SIGHUP 空闲窗判停读它。
- * 本文件产出的 `sessionResident` **只进总数、不进阻断集**:驻留 shell 不是一条腿,等它没有意义;一只不退出的 shell(`while true`)若阻断,崩溃孤儿引擎就永生。
- * 窗到 / 排空完成,退出边界的后台收割收掉它们,retain 行按 retain 既有语义活过受控退。
- *
- * ## 读法(本文件是唯一属主)
- * 行集 = core `TaskRegistry.liveTasks(access)` 的投影:`type ∈ {background_bash, monitor}` ∧ `status === "running"` ∧ `sessionScoped` ∧ 非 retain
- * ({@link isSessionResidentShellRow})。
- *  · **选座 `liveTasks`,不读 `list()`**:`list()` 是显示投影,硬帽 500 行(core 注:resolution must NEVER ride the display-capped list());
- *    进程级的在飞总数是外部判官判「引擎是否空闲」的依据,不能骑显示帽 —— 超过 500 行时 `list()` 会静默少数,方向恰是「以为空闲」。`liveTasks` 无显示帽。
- *  · **retain 行不计**:显式 retain 的行是「交付的活服务」,按 core 契约活过引擎的受控退(退出边界对它 `retained_skipped`),
- *    不是「引擎托管着、会随它收掉」的活 —— 报它,判官会把一个本就该活过引擎的服务读成引擎的负载。
- *  · **只数 shell 与 monitor**:后台 agent / workflow 行属计法表的别的类,不在这一类里。
- *  · **非会话驻留行不数**:挂在 run 腿上的后台行(`sessionScoped` 为假)随腿登记在 HTTP 腿项里,数它是第二次。
- *
- * ## 枚举源
- * core 的 `canAccess` 要求访问元组带 `scope`(缺 scope 一律拒),`list` / `liveTasks` 因此只读「调用方可达行」,没有进程总数的读口(core 不立新 getter)。
- * 进程级的数要由本仓自己枚举「本进程有哪些会话」:枚举源 = **围栏表**(`boot/execution-env.ts` 的 `SessionScopedRegistries.sessionOwners`):
- * 每次提交经 resolve-spec 写一笔(会话 id → 属主),删会话的 E21 级联清一笔,LRU 有界。scope 轴 = {@link sessionChildrenScope}(会话属主 `?? "default"`,
- * 删除门 / 换绑门 / 结清口 / 会话后台读面同一个取法,不另取)。
- *
- * ## 读到的边界(成文,不静默)
- *  · 围栏表是 LRU(上界 4096 会话):被挤出表的会话,它的驻留行在这里不可见 —— 回到改前的读数(不是新的错),不会多数;
- *  · 不经 resolve-spec 的内部车道(服务为自己起的 run)不写围栏表,它们起的会话驻留行同样不可见;
- *  · 删会话的级联在 `dropSessionScoped` 之后、后台收割之前失败(会话行因此没删)时,围栏表已先清:该会话还在跑的驻留行在下一次提交重新围栏之前不可见
- *    (同样回到改前的读数;修法是把 `dropSession` 的「清秘密」与「忘身份」拆开,属围栏表的属主,不在本读法里);
- *  · 每次读是 O(围栏表会话数 × 注册表行数)(`liveTasks` 逐会话走一遍注册表);表的上界 4096、注册表行数小,量级是毫秒。
- *
- * ## 读不出 ⇒ 非空闲(响亮,不替成 0)
- * 本函数在 `/health` 应答和崩溃遗言(uncaught 处理器里读总数)里被调,**不许抛**(崩溃遗言里一次抛会吞掉遗言本身)。判停路径(排空 / 租约 / SIGHUP)读阻断集,
- * 不求值本函数。某个会话的 `liveTasks` 读失败 ⇒ 该会话按 **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` 满足它。 */
 export type SessionOwners = Iterable<readonly [sessionId: string, owner: string | null]>;
-/** 这一类里的行判:唯一写处(计数与单测同读)。 */
-export declare function isSessionResidentShellRow(row: TaskListRow): boolean;
+/** 本文件交出的两项(键名属主 = {@link InflightBreakdown})。 */
+export type SessionResidentCounts = Pick<InflightBreakdown, "backgroundAgents" | "sessionResident">;
+/** 一行落在哪一项。 */
+export type SessionResidentTerm = keyof SessionResidentCounts;
+/**
+ * 行判:唯一写处(计数与单测同读)。`undefined` = 这一行不进在飞(理由见文件头的表)。闭集外的行类型 / 状态 ⇒ **抛**(由 {@link countSessionResidentBackground}
+ * 按「读不出」收:该会话计 1、报出)—— 不静默读成「不计」。
+ */
+export declare function sessionResidentTermOf(row: TaskListRow): SessionResidentTerm | undefined;
 /** 一个会话的驻留行读失败的报口(由调用方给出:装配层记运维行)。 */
 export type UnreadableSessionReport = (sessionId: string, err: unknown) => void;
+/** 一次停滞收割的结局:收掉了 `count` 行(> 0 才报)/ 收割本身抛了。闭集,装配层按 `kind` 穷举。 */
+export type StallReapOutcome = {
+    readonly kind: "reaped";
+    readonly count: number;
+} | {
+    readonly kind: "failed";
+    readonly err: unknown;
+};
+/** 停滞收割的策略:窗(ms,`BG_AGENT_STALL_MS`)与报口。读口必给 —— 没有「不收割」的读法。 */
+export interface StallReapPolicy {
+    readonly stallMs: number;
+    readonly report: (outcome: StallReapOutcome) => void;
+}
 /**
- * 本进程里会话驻留的、仍在跑的后台 shell / monitor 行数。`registry` 缺省 = 进程级单例;参数只供测试换桩(只用到 `liveTasks`)。
- * `onUnreadable` 必给:读失败的会话按 1 计并经它报出(文件头「读不出 ⇒ 非空闲」)。读法与边界见文件头。
+ * 本进程里会话驻留的、仍在跑的后台行,按项计数(一次走查交出两项)。**先收尸再数活**:走查之前按 `stall` 收一次停滞的后台子代理(文件头「停滞收割」)。
+ * `registry` 缺省 = 进程级单例;参数只供测试换桩(只用到 `reapStaleSessionBackgroundAgents` 与 `liveTasks`)。
+ * `onUnreadable` 必给:读失败的会话按 1 只在跑的后台子代理计并经它报出(文件头「读不出 ⇒ 非空闲」)。读法与边界见文件头。
  */
 export declare function countSessionResidentBackground(sessions: SessionOwners, opts: {
-    readonly registry?: Pick<TaskRegistry, "liveTasks">;
+    readonly registry?: Pick<TaskRegistry, "reapStaleSessionBackgroundAgents" | "liveTasks">;
     readonly onUnreadable: UnreadableSessionReport;
-}): number;
+    readonly stall: StallReapPolicy;
+}): SessionResidentCounts;
 //# sourceMappingURL=session-resident-background.d.ts.map

package/dist/session-resident-background.js

@@ -1,20 +1,89 @@
+import { writeLogText } from "./observability/logger.js";
 import { defaultTaskRegistry } from "@sema-agent/core";
-import { sessionChildrenScope } from "./session-children-retire.js";
-export function isSessionResidentShellRow(row) {
-    return (row.type === "background_bash" || row.type === "monitor") && row.status === "running" && row.sessionScoped && row.retained !== true;
+import { sessionTenantScope } from "./session-children-retire.js";
+function liveStatus(status) {
+    switch (status) {
+        case "pending":
+        case "running":
+            return true;
+        case "parked":
+        case "completed":
+        case "failed":
+        case "killed":
+        case "cancelled":
+            return false;
+        default: {
+            const unhandled = status;
+            throw new Error(`session-resident background: unknown task status ${String(unhandled)}`);
+        }
+    }
+}
+export function sessionResidentTermOf(row) {
+    if (!row.sessionScoped)
+        return undefined;
+    switch (row.type) {
+        case "background_agent":
+            return liveStatus(row.status) ? "backgroundAgents" : undefined;
+        case "background_bash":
+        case "monitor":
+            return liveStatus(row.status) && row.retained !== true ? "sessionResident" : undefined;
+        case "workflow":
+            return undefined;
+        default: {
+            const unhandled = row.type;
+            throw new Error(`session-resident background: unknown task type ${String(unhandled)}`);
+        }
+    }
 }
 export function countSessionResidentBackground(sessions, opts) {
     const registry = opts.registry ?? defaultTaskRegistry;
-    let n = 0;
+    reapStalled(registry, opts.stall);
+    let backgroundAgents = 0;
+    let sessionResident = 0;
+    const counted = new Set();
     for (const [sessionId, owner] of sessions) {
         try {
-            n += registry.liveTasks({ owner: sessionId, sessionId, scope: sessionChildrenScope(owner) }).filter(isSessionResidentShellRow).length;
+            const fresh = [];
+            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]);
+            }
+            for (const [taskId, term] of fresh) {
+                if (counted.has(taskId))
+                    continue;
+                counted.add(taskId);
+                if (term === "backgroundAgents")
+                    backgroundAgents += 1;
+                else
+                    sessionResident += 1;
+            }
         }
         catch (err) {
-            n += 1;
-            opts.onUnreadable(sessionId, err);
+            backgroundAgents += 1;
+            reportSafely(["session_resident_background_unreadable_report_threw", sessionId], () => opts.onUnreadable(sessionId, err));
         }
     }
-    return n;
+    return { backgroundAgents, sessionResident };
+}
+function reapStalled(registry, stall) {
+    let count;
+    try {
+        count = registry.reapStaleSessionBackgroundAgents(stall.stallMs);
+    }
+    catch (err) {
+        reportSafely(["background_agent_stall_report_threw"], () => stall.report({ kind: "failed", err }));
+        return;
+    }
+    if (count > 0)
+        reportSafely(["background_agent_stall_report_threw"], () => stall.report({ kind: "reaped", count }));
+}
+function reportSafely(fallbackLine, report) {
+    try {
+        report();
+    }
+    catch (reportErr) {
+        writeLogText("stderr", ...fallbackLine, reportErr);
+    }
 }
 //# sourceMappingURL=session-resident-background.js.map

package/dist/session-row.d.ts

@@ -30,7 +30,7 @@ export interface SessionRowTagInput {
  */
 export declare function sessionRowTagOf(row: SessionRowTagInput): string;
 /**
- * 列表行上的 `rowTag` 键(present-iff 这一行可被条件写 = 店有行写口 ∧ 行上有化身):三只店的列表行映射都经它,化身那一格由调用方经
+ * 列表行上的 `rowTag` 键(present-iff 这一行可被条件写 = 店有行写口 ∧ 行上有化身):local 店与 SQL 合成店(两方言一只)的列表行映射都经它,化身那一格由调用方经
  * `incarnationFromCell(…, "absent")` 解码好交进来(`undefined` = 行上没有令牌 ⇒ 键缺席,不铸)。
  */
 export declare function sessionRowTagKey(row: {
@@ -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-sync-kernel.d.ts

@@ -115,7 +115,7 @@ export declare const STAGED_LOG_BATCH = 500;
 /**
  * The ROW contract a staged entry must meet before it is batched — what the stores need to persist it, not a session-tree invariant
  * (those are core's): the SQL stores' `session_event` columns `entry_id` / `parent_id` are `VARCHAR(64)` and `type` is `VARCHAR(32) NOT NULL`
- * (`plugins/tidb-pool.ts` and `plugins/pg-session-storage.ts`, the DDL both staged appends write into; both dialects count characters, not
+ * (`plugins/tidb-pool.ts` and `stores-sql/pg-session-storage.ts`, the DDL both staged appends write into; both dialects count characters, not
  * UTF-16 units). An entry outside it used to reach the staging write and fail there as a store fault (5xx) — a client's bad data read as an
  * infrastructure failure. The local store holds the same contract (one gate for all stores: a log that cannot sync to SQL is refused at the door).
  */

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

@@ -6,7 +6,7 @@
  *  · **判官只有引擎一只**:每条腿起点一帧 `workspace_changed`(`cwd` / `root` / `entered?` / `project?` / `remote`),之后每变一帧;
  *    这条腿属于哪个项目由引擎对检出的 `.sema/project` 记号判一次(带了 `TaskSpec.projectId` 就必须等于记号,
  *    否则整腿拒 `config.project_identity_mismatch`;没有记号时声明就是身份)。本仓**不判**项目、不读记号。
- *  · **会话行只存一格**:`workspace` = 该会话上一条腿**自己的**最后一帧(SQL `session_meta.workspace`;local 店
+ *  · **会话行只存一格**:`workspace` = 该会话上一条腿**自己的**最后一帧(SQL `session_ext.workspace`;local 店
  *    `session-workspaces.json` 那一格)。成员由 {@link SESSION_WORKSPACE_DISPOSITIONS} 一张表定(引擎给帧加成员 ⇒ 表 tsc 红,
  *    门在 `trace/core-keyset-guard.ts` ⑰ 读同一张表)。**唯一写者** = 腿的记录座 {@link createSessionWorkspaceRecorder}
  *    (持流的四条腿逐帧喂同一只;委派子代转上来的帧 —— 带 `parentToolCallId` / `sourceTaskId` / `bgAgentId` —— 不是这条腿的位置,不认)。
@@ -27,7 +27,8 @@
  *    `TaskSpec.memory.projectKey`,按 git 仓库(origin 远端 / 本机路径)键控,与 `.sema/project` 记号无关;引擎 7.58.0 自己也写明
  *    「只声明的身份不改记忆的键」。两者是否该合成一个身份,是另一张设计票。
  *  · 多租户记忆分区(`proj:<租户>/<projectId>`)与登记簿种子读的是**这次提交**的 `projectId`(按提交挑盘,修前即如此),不读行。
- *  · 行上的 `root` / `cwd` / `entered` / `remote` 今天只存不读(会话面读它们归 wire 半场那一车);fork 出的新会话从「没有记录」起。
+ *  · 行上的项目还有一位读者:会话视图 `GET /v1/sessions/:id` 体顶层的 `projectId`(唯一读口 {@link readSessionProjectId},与视图的 `agent` 同一次视图读)。
+ *    `root` / `cwd` / `entered` / `remote` 今天只存不读;fork 出的新会话从「没有记录」起(项目声明按引擎契约每腿都带,fork 的首腿由调用方带上)。
  *  · **只回结果的腿(verify / cascade,含续跑的 verify 臂)不记行**:引擎在组合入口里自己排空内层腿的流,宿主手里没有流,而引擎给组合入口开的
  *    帧座(`onStatusEvent` / `onWiringManifest`)没有这一帧 ⇒ 这条腿的位置与项目到不了行,行停在更早一条腿的那一帧(没有记号的检出里,
  *    下一条不带 `projectId` 的提交续声明的是那一帧声明过的项目)。本仓不替引擎铸「这条腿站在哪里」;要引擎为组合入口开这一帧的座。
@@ -111,6 +112,14 @@ export interface SessionWorkspaceRecorder {
  * 这条腿的关键路径上,池饿死时这条腿本来就停;上界归部署(`DB_QUERY_TIMEOUT_MS`、MySQL 池的排队上界)。local 后端的写不经池。
  */
 export declare function createSessionWorkspaceRecorder(store: SessionWorkspaceStore | undefined, witness: DelegationRootWitness | undefined): SessionWorkspaceRecorder;
+/**
+ * 会话视图的 `projectId` —— **唯一读口**:行上最后一帧的 `project.id`(引擎对这只会话最后一条自己的腿的项目判决,记号判的与声明的同读;
+ * 「哪一种」不上 wire)。店没有这一面 / 没有记录 / 那一帧没有项目 ⇒ `undefined`(调用方不铸键)。两种读不出分两臂,与续声明那一读(`legProjectIdOf`)同读:
+ *  · 店读抛(库连接 / 超时)⇒ 原样上抛 —— 视图读响亮失败(与 `agent` 同律:缺键读作「这台 server 没有说」,不把一次故障说成这句话);
+ *  · 存下的那一格读不懂(被带外改坏)⇒ 店的同一只解码读作没有记录并计一次(F 类 `server.session-workspace.record-degraded`,`op=read`)⇒ 键缺席;
+ *    这只会话的下一条记帧的腿整格重写。
+ */
+export declare function readSessionProjectId(store: SessionWorkspaceStore | undefined, sessionId: string): Promise<string | undefined>;
 /**
  * **这条腿交给引擎的 `TaskSpec.projectId`**(唯一铸点;见文件头第三句)。`submitted` = 这次提交自己带的、已过形状门且折成小写的值
  * (新提交:鉴权口的 `resolvedProjectId`;续跑:持久化体的同一个键)。它在场就不读行。行读失败(库抖)原样上抛 —— 读不到「这只会话的项目」

package/dist/session-workspace.js

@@ -52,6 +52,11 @@ export function createSessionWorkspaceRecorder(store, witness) {
         },
     };
 }
+export async function readSessionProjectId(store, sessionId) {
+    if (store === undefined)
+        return undefined;
+    return (await store.readSessionWorkspace(sessionId))?.project?.id;
+}
 export async function legProjectIdOf(submitted, store, sessionId) {
     if (submitted !== undefined)
         return submitted;

package/dist/sighup-idle.d.ts

@@ -4,7 +4,7 @@
  * SIGHUP(壳窗口关闭打到整个进程组)≠「没人在用这只引擎」:共享引擎形态(同 config 多壳会话,引擎按
  * T11 防孤儿拍骑在首壳进程组里)下 peer 会话还活着——无条件 drain 会把 peer mid-turn 斩掉(499)且窗内
  * 新提交 503。这里改为:SIGHUP 不翻 draining(peer 零感知),armed 一只空闲窗——工作谓词连续 idleGraceMs
- * 为假才 shutdown,任何工作重置窗口(谓词的在飞格读阻断集 `drainState.blockingInflight` = `http + leader`;会话驻留的后台 shell / monitor
+ * 为假才 shutdown,任何工作重置窗口(谓词的在飞格读阻断集 `drainState.blockingInflight` = `http + leader + backgroundAgents`;会话驻留的后台 shell / monitor
  * 在 `/health.inflight` 总数里、不阻断)。真孤儿(最后一窗关掉)
  * 有界自灭=T11 保留;第二个 SIGHUP 升级 escalate(既有 drain 路径,操作员硬梯子)。
  *

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