@sema-agent/server 7.145.0 → 7.147.0

package/dist/http/route-ctx.d.ts

@@ -19,7 +19,7 @@ import type { HostDecision } from "../host-decision.js";
 import type { EntryProblem } from "../entry-problems.js";
 import type { SessionOwnerCell } from "../security.js";
 import type { SessionNotifyDoor } from "../session-notify-door.js";
-import type { TaskStream, TaskSpec, TaskResult, QuestionAnswer, Checkpoint, CheckpointToken, ResumeOutcome, RunInternals, Runner, EngineNotice } from "@sema-agent/core";
+import type { TaskStream, TaskSpec, TaskResult, QuestionAnswer, Checkpoint, CheckpointToken, ResumeOutcome, RunInternals, Runner, EngineNotice, PendingSteerInput } from "@sema-agent/core";
 import type { FlatServiceDeps, RequestAuth } from "./server.js";
 import type { TaskRequestBody, DecideBinding } from "./wire-types.js";
 import type { IdempotencyCache, SubmitOutcome } from "./idempotency.js";
@@ -36,6 +36,7 @@ import type { PeerLease } from "../peer-seat.js";
 import type { RootedTaskSpec } from "./execution-context.js";
 import type { GateCommitment, GateSettlementEvidence } from "../gate-settlement.js";
 import type { ResumeRestatement } from "./resume-restatement.js";
+import type { RememberLaneCannotRecord } from "../parked-decide.js";
 /** 跨域可变状态 = lens1 §C2 实测的那 8 条「运行期登记簿」,一个对象。
  *  [ref]:`cancelledViaVerb`(按 taskId 键控的「这次是取消动词」旁表)删除 —— 中止成因改挂在每条腿自己的
  *  {@link RunAbort} 句柄上(`inflightRuns` 的值),同寿同删,不再有一张与腿不同寿的旁表。 */
@@ -79,6 +80,12 @@ export interface RouteHelpers {
     ownerLeaseDenied(res: ServerResponse, owner: string | undefined): Promise<boolean>;
     /** [ref]-T1:治理窗 pre-admission(异步 202 车道的唯一 429 出路;key 公式与 core 单源)。 */
     usageWindowDenied(req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+    /**
+     * 在飞 run 并发帽的提交门准入(`RUN_MAX_CONCURRENT*`,缺省关;判据、席位与拒的形全文在 `http/run-concurrency-cap.ts`):放行 ⇒ 席位(登记那一拍与 `finally` 放);
+     * 超帽 ⇒ 已应答 429 + `Retry-After`、回 `undefined`。只挂**新提交**门(`createDurableRun` / `POST /v1/tasks` / `POST /v1/tasks/stream`),
+     * 排在幂等重放与 `usageWindowDenied` 之后、任何建行 / 认领 / SSE 头之前。
+     */
+    admitRun(req: IncomingMessage, res: ServerResponse): import("./run-concurrency-cap.js").RunSlot | undefined;
     safeDecode(seg: string): string | null;
     /** run 面的属主门(谓词 `runOwnerReadable`;非属主 ⇒ 404 `not_found.run` + 长文,与 run 读口的 unknown 臂同码同串,[ref])。 */
     runOwnerOk(req: IncomingMessage, res: ServerResponse, owner: string | null): boolean;
@@ -191,17 +198,10 @@ export interface CheckpointCtx {
      * 传原 ctx / 其展开 ⇒ 标随行。缺席 = 不是无人值守腿(HTTP 提交腿;7.106.0 前落盘的行 —— 那时这些腿不铸模式,checkpoint 里也没有)。
      */
     unattendedLeg?: true;
-    /**
-     * 体里 `settings.permissions.allow` 的**读法记号**(闭集只有当前读法一词 `"allow_layer"`):在场 = 这一行是当前读法下写下的、体里带非空 `allow`,
-     * 它按「交给引擎的 allow 层」写、也按它读。**服务端写、不来自请求体**(与 {@link unattendedLeg} 同为 `body` 的兄弟键)。
-     * 缺席(≤7.114.0,名单时代)或旧词 `"statement"`(7.115.0–7.116.x,表态时代)而体里带非空 `allow` ⇒ 续跑腿响亮拒、行字节不动(规则与删除条件的属主 = `http/checkpoint-ctx.ts` 顶注)。
-     * 写点只有 `buildCheckpointCtx`(同模块;新的持久化写);续跑腿的写回传原 ctx / 其展开 ⇒ 记号随行。体里没有 `allow` 的行不写它。
-     */
-    permissionsAllowReading?: import("./checkpoint-ctx.js").PermissionsAllowReading;
     /**
      * 体里**模式词的读法记号**(闭集只有当前一词 `"entry_word"`):在场 = 这一行体的顶层 `permissionMode` 是这条 run 模式词唯一的源(提交入口盖过运维
      * `AUTONOMY=plan` 的地板;`plan_review` 写回改它),续跑照它读。**服务端写、不来自请求体**。缺席(7.121.x 及以前写下的行 —— 那时运维的 plan 由治理层每段重钳)
-     * 而本部署此刻有入口地板、体的词被地板钳会变 ⇒ 续跑腿响亮拒、行字节不动(规则与删除条件的属主 = `http/checkpoint-ctx.ts` 顶注第三问)。
+     * 而本部署此刻有入口地板、体的词被地板钳会变 ⇒ 续跑腿响亮拒、行字节不动(规则与删除条件的属主 = `http/checkpoint-ctx.ts` 顶注「模式词问」)。
      * 写点两个(写模式词的人盖记号,同模块):`buildCheckpointCtx`(每一次新的持久化写都写)与 `withPermissionModeRewritten`(`plan_review` 改词的写回);
      * 不改词的续跑腿写回传原 ctx ⇒ 记号随行。
      */
@@ -210,8 +210,10 @@ export interface CheckpointCtx {
      * 🔴 [ref] —— **写这份上下文的服务版本**(`package.json` 的 `version`),**服务端写、不来自请求体**(与 {@link unattendedLeg} 同为 `body` 的兄弟键)。
      * 写点两个:`buildCheckpointCtx`(每一次新的持久化写)与续跑腿的写回({@link DriveResumeArgs.resumeCtx} 的唯一写点,CAS 赢点盖本进程的版本 —— 接下来写下一张停车行的就是它)。
      * 读者:`checkpoint.unsupported_version` 的 409 体 —— 原样带出 `writerVersion`,与本引擎的 `readerVersion` 并列(运维据此知道该回哪一版去决);
-     * 两键唯一铸法 `checkpoint-ctx.ts` `buildCheckpointVersionKeys`,本码每个铸点同调。它是**上下文**,不是拒因:成因与码都不读它。
-     * 缺席 = 本版之前写下的行(不回填):那一码的体不带两键,如实不猜。不是一次性迁移 —— 这一格是常设的事实位,没有删除条件。
+     * 两键唯一铸法 `checkpoint-ctx.ts` `buildCheckpointVersionKeys`,本码每个铸点同调。
+     * 另一个读者(唯一的拒因读者):存体重放判据的 allow 读法问(`checkpoint-ctx.ts` 顶注)—— 体里带非空 `settings.permissions.allow` 而本格证不出 ≥ 7.117.0 ⇒ 拒。
+     * 所以写点守一条律:盖本格的写只在本进程按当前读法读过这份体之后(新提交;或已过存体重放判据的续跑写回),在判据之前盖 = 把旧行洗成新行。
+     * 缺席 = 7.124.0 之前写下的行(不回填):那一码的体不带两键,如实不猜;allow 读法问把它读作「证不出」。不是一次性迁移 —— 这一格是常设的事实位,没有删除条件。
      */
     writerVersion?: string;
     /**
@@ -420,6 +422,7 @@ export interface PreparedPlanReview {
     readonly sessionId: string;
     readonly token: CheckpointToken;
     readonly cp: Checkpoint;
+    /** 这条决断唯一的一次 ctx 读,**已盖过**续跑请求的重述键(缺席 = 存量体原样):存体预判判的、驱动段重建与写回读的都是这一份。 */
     readonly ctx: CheckpointCtx;
 }
 /** 提交/续跑「腿」= 跨域共享的**有状态**长流程(不像 {@link RouteHelpers} 那样只依赖 deps/config:它们要写
@@ -458,14 +461,8 @@ export interface RouteLegs {
     /** 这次决定落在哪一个动作上:调用方点名它看到的那一对(`boundCallId` + `boundInputHash`);缺任一 ⇒ 400 `decide_requires_binding`
      *  (判在门型守卫之后,判官 `decidedActionOf`)。本函数从不拿当前停驻行补。 */
     binding: DecideBinding, 
-    /** [ref] codex R4(验真后修):remember 豁免的 grant 挂点。**工具名不再由路由自己读**(那是与本函数
-     *  载入行分歧的第三次 scope-less 读,三读分歧下会给他人工具落豁免=提权)——由本函数把**已属主校验的
-     *  载入 cp** 的可记工具名(`rememberableToolName`,非 tool_approval / AskUserQuestion / legacy null / [ref] 强制卡 ⇒ `null`
-     *  = 无可记)一并回传,路由只对这个逐字落店。`overrideSessionId` = parked 腿的 root/host 会话 grant 锚。 */
-    onResumeCommitted?: (grant: {
-        overrideSessionId?: string;
-        rememberableToolName: string | null;
-    }) => Promise<void>, 
+    /** 这次决定带着「本会话放行」请求({@link RememberSessionRequest})⇒ 本函数是它的**唯一铸点**,结局的 `rememberApplied` 是它的答({@link ResumeCheckpointOutcome})。 */
+    remember?: RememberSessionRequest, 
     /** [ref]:透传给 {@link DriveResumeArgs.acceptEarly}(200 受理语义)。HTTP `/decide` 腿传 `true`;
      *  内部 D-D SLA deny-sweep 不传 —— 它没有在等响应的人,提前受理对它零收益而少一条同步失败面。 */
     acceptEarly?: boolean, 
@@ -476,7 +473,7 @@ export interface RouteLegs {
         explicitOperator: boolean;
     }, 
     /** 续跑请求的重述键(`mcpServers` / `a2aPeers`),门读出并判过的那一份;缺席 = 冻结读法。语义属主 = `resume-restatement.ts` 顶注。 */
-    restatement?: ResumeRestatement): Promise<ResumeLegOutcome>;
+    restatement?: ResumeRestatement): Promise<ResumeCheckpointOutcome>;
     /** 全 resume 家族的共同下半场(lease admission + 写 run log + fleet 发布)。 */
     driveResumeIntoRunLog(args: DriveResumeArgs): Promise<ResumeLegOutcome>;
     /** assistant 抢占腿的复位(gate-kind 守卫 + 行级属主复核 + 驱动)。 */
@@ -492,7 +489,9 @@ export interface RouteLegs {
     /** 续跑请求的重述键(同 {@link RouteLegs.resumeCheckpoint} 末参)。 */
     restatement?: ResumeRestatement): Promise<ResumeLegOutcome>;
     /** notify-wake 域:唤醒一条 parked checkpoint。 */
-    resumeWake(sessionId: string, message: string | undefined, caller: string | undefined, req: IncomingMessage | undefined, 
+    resumeWake(sessionId: string, 
+    /** 续跑首轮那段话连同框架位,由文本出处在铸点定好(HTTP `/wake` 正文 ⇒ `trusted: false`);语义属主 = `resume-legs.ts` 同名形参顶注。 */
+    message: PendingSteerInput | undefined, caller: string | undefined, req: IncomingMessage | undefined, 
     /** [ref] 件 S-1:透传给 {@link DriveResumeArgs.acceptEarly}(200 受理语义)。HTTP `/wake` 腿传 `true`
      *  —— 本腿走 `mintFreshRun`,受理体里的 `taskId` 因此是**新铸的**那个(壳的 poll 锚)。 */
     acceptEarly?: boolean, 
@@ -521,7 +520,9 @@ export interface RouteLegs {
         explicitOperator: boolean;
     }, 
     /** [ref]:决断方看到的那道门(决断体的 `checkpointId`);不是当前门 ⇒ `409 approval_stale`(`approval_stale` 律,语义属主 = `resume-legs.ts` 的同名形参顶注)。 */
-    sighting?: GateSighting): Promise<{
+    sighting?: GateSighting, 
+    /** 续跑请求的重述键(同 {@link RouteLegs.resumeCheckpoint} 末参):盖在这一次 ctx 读上,存体预判按盖过的体判。 */
+    restatement?: ResumeRestatement): Promise<{
         readonly ok: false;
         readonly answer: {
             status: number;
@@ -539,9 +540,7 @@ export interface RouteLegs {
     acceptEarly?: boolean, 
     /** [ref]:批准之后这条会话继续用的 permission mode(闭集 `PLAN_APPROVE_PERMISSION_MODES_AFTER`;只在把计划带出 plan 的决定
      *  —— `approve` / `edit` —— 上有意义,缺席 ⇒ `"default"`)。语义与判据的唯一属主 = `resume-legs.ts` 的同名形参顶注。 */
-    permissionModeAfter?: PlanApprovePermissionModeAfter, 
-    /** 续跑请求的重述键(同 {@link RouteLegs.resumeCheckpoint} 末参)。 */
-    restatement?: ResumeRestatement): Promise<ResumeLegOutcome>;
+    permissionModeAfter?: PlanApprovePermissionModeAfter): Promise<ResumeLegOutcome>;
     /** 会话通知门(`POST /v1/sessions/:id/notify` 与 Runner 之外的后台子代完成共用的那一只;活流登记簿是本服务的,门随服务建一次)。 */
     sessionNotify: SessionNotifyDoor;
 }
@@ -693,7 +692,7 @@ interface RouteDeclIdentity {
     readonly methods: readonly RouteMethod[];
     /**
      * 「这条 GET 开的是一条**只读订阅**」—— 一条 SSE 读面(推送队列 / 账本 tail),它看着别人干活,自己不是活([ref])。
-     * 在场 ⇒ 分派器不把它记进在飞(`drainState.inflight()`:排空等的、`/health` 报的、SIGHUP 空闲窗与附着租约读的那一只),只记进附着
+     * 在场 ⇒ 分派器不把它记进在飞(`http` 项:`/health.inflight` 报的总数与排空等的、SIGHUP 空闲窗与附着租约读的阻断集都从它起算),只记进附着
      * (`attachedStreams()`:壳还挂在这只引擎上);排空进入那一拍(以及硬停起点)由分派器发一帧 `draining` 终帧后关掉它
      * (`drainState.endSubscriptions`)。闭集 = 八条 GET SSE 读面,逐行理由见各行注;**唯一**一条「在飞腿的流」`POST /v1/tasks/stream`
      * 不带它 —— 那条流就是 sync 腿本身(关流 = 断连语义),照旧算在飞。漏标一条订阅的方向是**多算在飞**(排空多等),不是少等。
@@ -739,6 +738,24 @@ export interface ResumeLegOutcome {
     status: number;
     body: object;
 }
+/**
+ * 「本会话不再询问」的请求 —— **两扇门同一只**:`/decide` 体上的 `remember:"session"`、应答口(`POST /v1/tool-approvals/:id/respond`)命中停驻行的
+ * `allow_session`。铸点只有一只:{@link RouteLegs.resumeCheckpoint} —— 可记与否从**已属主校验的载入停驻行**判(`standingAnswerDurablyRecordable`,
+ * 与运维队列行的 `rememberRefused` 同一只判据)、锚由车道定(任务级 = 这个会话;bg 停驻子代 = 行的 root/host 会话)、落豁免店**只在**这次决定
+ * 被证明已结清之后(`decisionCommittedOf`)、`rememberApplied` = 落没落(店抛 ⇒ `false` + warn,这次的放行不回滚)。门自己不写店、不判可记。
+ * 两口唯一的差 = `laneCannotRecord`(记不住的车道上怎么答;闭集与理由的属主 = `parked-decide.ts` 的 {@link RememberLaneCannotRecord})。
+ */
+export interface RememberSessionRequest {
+    /** 豁免行的签发人(`grantedBy`)= 门已验的身份(`/decide` 的决断方 / 应答口的调用方);匿名开放部署 ⇒ `null`。 */
+    readonly grantedBy: string | null;
+    readonly laneCannotRecord: RememberLaneCannotRecord;
+}
+/** {@link RouteLegs.resumeCheckpoint} 的结局 = 腿的应答 + 带了「本会话放行」请求时铸点的答(`rememberApplied`:落没落)。键只在证得出提交的两条车道
+ *  (bg 停驻子代赎回 / 任务级续跑)的结清点上铸;其余出口(拒 / workflow 投递 / 抛)键缺席 ⇒ 门读作「没记住」(`=== true`)。
+ *  这一位是进程内的结局位,不进 `body` —— 由门决定挂不挂到回执上(两扇门都只挂在这次真做了授予判定的回执上;幂等回放不挂)。 */
+export type ResumeCheckpointOutcome = ResumeLegOutcome & {
+    readonly rememberApplied?: boolean;
+};
 /**
  * **「决定/续跑已受理」那一枚 200 收据的单一铸点**([ref])。
  *

package/dist/http/route-table.js

@@ -4,6 +4,7 @@ import { handleDiagnostics, DIAGNOSTICS_ROUTES } from "./routes/diagnostics.js";
 import { handleAdoption, ADOPTION_ROUTES } from "./routes/adoption.js";
 import { handleRetention, RETENTION_ROUTES } from "./routes/retention-ops.js";
 import { handleAdminDrain, ADMIN_DRAIN_ROUTES } from "./routes/admin-drain.js";
+import { handleEngine, ENGINE_ROUTES } from "./routes/engine.js";
 import { handleDevices, DEVICES_ROUTES } from "./routes/devices.js";
 import { handleAdminConfigRefresh, ADMIN_CONFIG_REFRESH_ROUTES } from "./routes/admin-config-refresh.js";
 import { handleConfigCatalog, CONFIG_CATALOG_ROUTES } from "./routes/config-catalog.js";
@@ -18,6 +19,7 @@ import { handlePrincipalInbox, PRINCIPAL_INBOX_ROUTES } from "./routes/principal
 import { handleRules, RULES_ROUTES } from "./routes/rules.js";
 import { handleSessionsList, SESSIONS_LIST_ROUTES } from "./routes/sessions-list.js";
 import { handleAgentRoster, AGENT_ROSTER_ROUTES } from "./routes/agents-roster.js";
+import { handleProjects, PROJECTS_ROUTES } from "./routes/projects.js";
 import { handleSessions, SESSIONS_ROUTES } from "./routes/sessions.js";
 import { handleSessionSync, SESSION_SYNC_ROUTES } from "./routes/session-sync.js";
 import { handleAttachments, ATTACHMENTS_ROUTES } from "./routes/attachments.js";
@@ -65,6 +67,7 @@ export const ROUTES = [
     row({ handler: handleAdoption, decls: ADOPTION_ROUTES, position: "post-credential", label: "adoption" }),
     row({ handler: handleRetention, decls: RETENTION_ROUTES, position: "post-credential", label: "retention" }),
     row({ handler: handleAdminDrain, decls: ADMIN_DRAIN_ROUTES, position: "post-credential", label: "admin-drain" }),
+    row({ handler: handleEngine, decls: ENGINE_ROUTES, position: "post-credential", label: "engine" }),
     row({ handler: handleDevices, decls: DEVICES_ROUTES, position: "post-credential", label: "devices" }),
     row({ handler: handleAdminConfigRefresh, decls: ADMIN_CONFIG_REFRESH_ROUTES, position: "post-credential", label: "admin-config-refresh" }),
     row({ handler: handleConfigCatalog, decls: CONFIG_CATALOG_ROUTES, position: "post-credential", label: "config-catalog" }),
@@ -79,6 +82,7 @@ export const ROUTES = [
     row({ handler: handlePrincipalInbox, decls: PRINCIPAL_INBOX_ROUTES, position: "post-credential", label: "principal-inbox" }),
     row({ handler: handleSessionsList, decls: SESSIONS_LIST_ROUTES, position: "post-credential", label: "sessions-list" }),
     row({ handler: handleAgentRoster, decls: AGENT_ROSTER_ROUTES, position: "post-credential", label: "agent-roster" }),
+    row({ handler: handleProjects, decls: PROJECTS_ROUTES, position: "post-credential", label: "projects" }),
     row({ handler: handleSessions, decls: SESSIONS_ROUTES, position: "post-credential", label: "sessions" }),
     row({ handler: handleSessionSync, decls: SESSION_SYNC_ROUTES, position: "post-credential", label: "session-sync" }),
     row({ handler: handleAttachments, decls: ATTACHMENTS_ROUTES, position: "post-credential", label: "attachments" }),

package/dist/http/routes/adoption.d.ts

@@ -18,6 +18,11 @@
  * 一次落库,此后原样回放)。并发同参 POST 由 `adoption_log.from_principal` 的 UNIQUE 仲裁:恰一行落库,
  * 两条连接拿到同一个 adoptionId、同一份回执。
  *
+ * ── 第二条车道:源主体的批量导入 `POST /v1/adoption/:id/sessions` ─────────────────────────────────────────────
+ * 不是 operator 面:调用者是那条收编行的**源主体本人**(逐字;operator 不能代),把本地会话导进目的主体名下。门序 = 身份(401)→ 设施(501)→
+ * 行(404 `not_found.adoption`)→ 源主体(403 `auth.adoption_source_only`,不降级成 404:无行与不匹配同形是一种查不出根因的二义)→ 收编态
+ * (409 `adoption.not_adopted`)→ 体形(400)→ 条数帽(400)→ 逐元素(200 + 结局数组)。判断全在 `adoption/import.ts`,本模块只下发。
+ *
  * 分层:本模块不值 import `server.ts`(那条边闭合运行时装载环),只 `import type`。
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
@@ -33,6 +38,12 @@ export declare const ADOPTION_ROUTES: readonly [{
     readonly pattern: RegExp;
     readonly label: "/v1/adoption/:id";
     readonly methods: readonly ["GET"];
+}, {
+    readonly id: "adoption-sessions-import";
+    readonly pattern: RegExp;
+    readonly label: "/v1/adoption/:id/sessions";
+    readonly credentialGated: readonly ["POST"];
+    readonly methods: readonly ["POST"];
 }];
 /** 本域可分派行的 `id` 闭集 —— handler 的 `switch` 按它判穷尽(漏一口 = 编译红)。 */
 export type AdoptionRouteId = RouteIdsOf<typeof ADOPTION_ROUTES>;

package/dist/http/routes/adoption.js

@@ -1,6 +1,8 @@
 import { createAdoptionRunner } from "../../adoption/runner.js";
 import { AdoptionRequestSchema } from "../../adoption/wire.js";
 import { checkAdoptionPrincipalShape, checkAdoptionWidths } from "../../adoption/plan.js";
+import { judgeAdoptionImportBinding, readAdoptionImportBody, runAdoptionImport } from "../../adoption/import.js";
+import { limitRefusal } from "../../limit-refusal.js";
 import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk, sendOperatorPrincipalsRequired, sendPrincipalRefusal } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
@@ -39,7 +41,21 @@ function sendOutcome(res, out) {
 function assertNoRejectCodeLeft(unhandled) {
     throw new Error(`adoption: unhandled reject code ${JSON.stringify(unhandled)} — the wire contract's closed set and this switch have drifted apart`);
 }
+function sendAdoptionStoreRequired(res) {
+    sendError(res, 501, "capability.adoption_store_required", "adoption requires a SQL store backend (DB_BACKEND=mysql|pg)");
+}
 export async function handleAdoption(req, res, match, ctx) {
+    switch (match.decl.id) {
+        case "adoption-submit":
+        case "adoption-detail":
+            return operatorLane(req, res, match.decl.id, match.params, ctx);
+        case "adoption-sessions-import":
+            return sourceLane(req, res, match.params, ctx);
+        default:
+            return assertNever(match.decl.id);
+    }
+}
+async function operatorLane(req, res, id, params, ctx) {
     const { deps } = ctx;
     const { readJson } = ctx.helpers;
     const principal = gatedPrincipal(req, deps.config);
@@ -59,7 +75,7 @@ export async function handleAdoption(req, res, match, ctx) {
     if (!fact.available) {
         switch (fact.why) {
             case "adoption_store_absent":
-                sendError(res, 501, "capability.adoption_store_required", "adoption requires a SQL store backend (DB_BACKEND=mysql|pg)");
+                sendAdoptionStoreRequired(res);
                 return;
             case "operator_principals_empty":
                 sendOperatorPrincipalsRequired(res);
@@ -70,14 +86,14 @@ export async function handleAdoption(req, res, match, ctx) {
     }
     const store = fact.backend.adoptionLog();
     const runner = createAdoptionRunner({ store, dialect: deps.backend?.kind === "pg" ? "pg" : "mysql", now: Date.now, logger: deps.logger });
-    switch (match.decl.id) {
+    switch (id) {
         case "adoption-detail": {
-            const id = ctx.helpers.safeDecode(match.params.id);
-            if (id === null) {
+            const adoptionId = ctx.helpers.safeDecode(params.id);
+            if (adoptionId === null) {
                 sendError(res, 400, "request.id_invalid", "invalid adoption id");
                 return;
             }
-            const out = await runner.get(id);
+            const out = await runner.get(adoptionId);
             if (!out) {
                 sendError(res, 404, "not_found.adoption", "adoption not found");
                 return;
@@ -112,11 +128,69 @@ export async function handleAdoption(req, res, match, ctx) {
             return;
         }
         default:
-            return assertNever(match.decl.id);
+            return assertNever(id);
+    }
+}
+async function sourceLane(req, res, params, ctx) {
+    const { deps } = ctx;
+    if (ctx.helpers.rateLimited(req, res))
+        return;
+    const principal = gatedPrincipal(req, deps.config);
+    if (principal === undefined) {
+        sendPrincipalRefusal(res, req, deps.config);
+        return;
+    }
+    const face = facts.adoptionSessionImport(deps);
+    if (!face.available) {
+        switch (face.why) {
+            case "adoption_store_absent":
+                sendAdoptionStoreRequired(res);
+                return;
+            case "session_import_staging_absent":
+                sendError(res, 501, "capability.session_store_required", "importing sessions requires a durable session store (DB_BACKEND=mysql|pg|local)");
+                return;
+            default:
+                return assertNever(face.why);
+        }
+    }
+    const adoptionId = ctx.helpers.safeDecode(params.id);
+    if (adoptionId === null) {
+        sendError(res, 400, "request.id_invalid", "invalid adoption id");
+        return;
+    }
+    const binding = judgeAdoptionImportBinding(await face.backend.adoptionLog().getById(adoptionId), principal);
+    switch (binding.kind) {
+        case "absent":
+            sendError(res, 404, "not_found.adoption", "adoption not found");
+            return;
+        case "not_source":
+            sendError(res, 403, "auth.adoption_source_only", "only this adoption's source principal may import sessions into it (verbatim; an operator cannot import on its behalf)");
+            return;
+        case "not_adopted":
+            sendError(res, 409, "adoption.not_adopted", "this adoption has not completed (it is still in flight, or it was rejected); sessions can be imported once the operator's adoption reaches status adopted");
+            return;
+        case "bound":
+            break;
+        default:
+            return assertNever(binding);
+    }
+    const sessions = readAdoptionImportBody(await ctx.helpers.readJson(req));
+    if (sessions === undefined) {
+        sendError(res, 400, "request.body_shape", "invalid import body — expected exactly {sessions: [...]} (the destination is the adoption's; the body cannot name one)");
+        return;
+    }
+    const cap = deps.config.adoptionImportMaxSessions;
+    if (sessions.length > cap) {
+        const refusal = limitRefusal("sessions", "entries", sessions.length, cap, { tail: "split the batch (the current cap is capabilities.adoptionImport.maxSessions), or have the operator raise ADOPTION_IMPORT_MAX_SESSIONS" });
+        sendError(res, 400, "request.field_invalid", refusal.message, refusal.facts);
+        return;
     }
+    const results = await runAdoptionImport({ adoptionId: binding.adoptionId, toPrincipal: binding.toPrincipal, maxSessionBytes: deps.config.adoptionImportMaxSessionBytes, sessionStorage: face.sessionStorage }, sessions);
+    sendJson(res, 200, { results });
 }
 export const ADOPTION_ROUTES = [
     { id: "adoption-submit", path: "/v1/adoption", credentialGated: ["POST"], methods: ["POST"] },
     { id: "adoption-detail", pattern: /^\/v1\/adoption\/(?<id>[^/]+)$/, label: "/v1/adoption/:id", methods: ["GET"] },
+    { id: "adoption-sessions-import", pattern: /^\/v1\/adoption\/(?<id>[^/]+)\/sessions$/, label: "/v1/adoption/:id/sessions", credentialGated: ["POST"], methods: ["POST"] },
 ];
 //# sourceMappingURL=adoption.js.map

package/dist/http/routes/agents-roster.js

@@ -20,6 +20,7 @@ const ROSTER_KEY_DISPOSITION = {
     parentSessionId: "strip",
     rootSessionId: "strip",
     usage: "strip",
+    requestedBy: "strip",
 };
 void ROSTER_KEY_DISPOSITION;
 export function rosterAgentId(row) {

package/dist/http/routes/approvals-assistant.js

@@ -3,7 +3,8 @@ import { skillCardFacts } from "../../approval-card.js";
 import { hostDecisionFacts, readDecider, retiredDecisionKeyFacts, DECIDED_BY_NOT_IN_PROOF } from "../../host-decision.js";
 import { sameExecutionRecord } from "@sema-agent/core";
 import { findParkedAgentForCheckpoint } from "../../parked-decide.js";
-import { DECIDED_REPLAY_SCAN_CAP, approvalPayloadFingerprint } from "../../plugins/checkpoint-store-sql.js";
+import { DECIDED_REPLAY_SCAN_CAP } from "../../plugins/checkpoint-store-face.js";
+import { approvalPayloadFingerprint } from "../../plugins/approval-payload-fingerprint.js";
 import { carriesDeploymentListQuestion, standingAnswerDurablyRecordable } from "../../tool-approval.js";
 import { APPROVAL_GATE_KINDS } from "../../approval-content-kind.js";
 import { isParkedRunStatus } from "../../plugins/store-contracts.js";
@@ -31,7 +32,7 @@ import { recordFailOpen } from "../../observability/fail-open.js";
 import { MAX_CHECKPOINT_ID_CHARS, durableRowIdentity } from "../../checkpoint-identity.js";
 import { MAX_KEY_ECHO, keyClosureClause, scanKeyClosure } from "../../request-key-closure.js";
 import { fieldConflictFacts } from "../../field-conflict.js";
-import { buildSettlementEvidence, decisionCommittedOf } from "../../gate-settlement.js";
+import { buildSettlementEvidence } from "../../gate-settlement.js";
 import { seatText } from "../../trace/exit-seat.js";
 import { approvalQueueKindOfDoorId } from "../../approval-queue-kind.js";
 import { defaultPeerInboundFace, parsePeerInboundId, peerBoxScope } from "../../peer-inbound-face.js";
@@ -700,7 +701,7 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
                 sendError(res, 404, "not_found.run", "task not found");
                 return;
             }
-            const plan = await preparePlanReview(run.sessionId, { taskId, principalPresent: principal !== undefined }, { principal: deciderPrincipal, explicitOperator }, sighting);
+            const plan = await preparePlanReview(run.sessionId, { taskId, principalPresent: principal !== undefined }, { principal: deciderPrincipal, explicitOperator }, sighting, restated.restatement);
             if (!plan.ok) {
                 sendResumeOutcome(res, plan.answer, deps.logger);
                 return;
@@ -724,7 +725,7 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
                     return;
                 }
             }
-            const out = await drivePlanReview(plan.prepared, decision, decision === "edit" ? body.editedPlan : undefined, typeof body.reason === "string" ? body.reason : undefined, hostDecisionFacts(decidedByReading.decider, deciderPrincipal), req, true, isPlanApprovePermissionModeAfter(body.permissionModeAfter) ? body.permissionModeAfter : undefined, restated.restatement);
+            const out = await drivePlanReview(plan.prepared, decision, decision === "edit" ? body.editedPlan : undefined, typeof body.reason === "string" ? body.reason : undefined, hostDecisionFacts(decidedByReading.decider, deciderPrincipal), req, true, isPlanApprovePermissionModeAfter(body.permissionModeAfter) ? body.permissionModeAfter : undefined);
             sendResumeOutcome(res, out, deps.logger);
             return;
         }
@@ -892,27 +893,7 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
                     return;
                 }
             }
-            let rememberApplied = false;
-            let pendingGrant;
-            const grantOnCommit = remember && deps.approvalExemptionStore
-                ? async (grant) => {
-                    const canonical = grant.rememberableToolName;
-                    if (!canonical)
-                        return;
-                    pendingGrant = { sessionId: grant.overrideSessionId ?? sessionId, toolName: canonical };
-                }
-                : undefined;
-            const out = await resumeCheckpoint(sessionId, decision, body.reason ?? undefined, hostDecisionFacts(decider, deciderPrincipal), req, answer, binding, grantOnCommit, true, { principal: deciderPrincipal, explicitOperator }, restated.restatement);
-            if (pendingGrant !== undefined && decisionCommittedOf(out) && deps.approvalExemptionStore) {
-                try {
-                    await deps.approvalExemptionStore.grant(pendingGrant.sessionId, pendingGrant.toolName, deciderPrincipal ?? null);
-                    rememberApplied = true;
-                    deps.logger?.info?.("approval_exemption_granted", { sessionId: pendingGrant.sessionId, toolName: pendingGrant.toolName, grantedBy: deciderPrincipal ?? null });
-                }
-                catch (e) {
-                    deps.logger?.warn?.("approval_exemption_grant_failed", { sessionId: pendingGrant.sessionId, toolName: pendingGrant.toolName, error: String(e).slice(0, 200) });
-                }
-            }
+            const out = await resumeCheckpoint(sessionId, decision, body.reason ?? undefined, hostDecisionFacts(decider, deciderPrincipal), req, answer, binding, remember ? { grantedBy: deciderPrincipal ?? null, laneCannotRecord: "refuse" } : undefined, true, { principal: deciderPrincipal, explicitOperator }, restated.restatement);
             const replay = await decideIdempotentReplay(cs, {
                 sessionId,
                 out,
@@ -932,7 +913,7 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
                 sendResumeOutcome(res, replay, deps.logger);
                 return;
             }
-            sendResumeOutcome(res, out, deps.logger, remember && deps.approvalExemptionStore ? { rememberApplied } : undefined);
+            sendResumeOutcome(res, out, deps.logger, remember ? { rememberApplied: out.rememberApplied === true } : undefined);
             return;
         }
     }

package/dist/http/routes/background.js

@@ -23,6 +23,7 @@ const ROW_KEY_DISPOSITION = {
     toolUseId: "strip",
     updatedAt: "strip",
     sessionId: "keep",
+    requestedBy: "strip",
 };
 void ROW_KEY_DISPOSITION;
 function projectRow(r) {

package/dist/http/routes/capabilities.js

@@ -25,6 +25,7 @@ import { projectWriteProtectionCapability } from "../../write-protection.js";
 import { projectStoreCapability } from "../../store-posture.js";
 import { projectWebSearchCapability } from "../../plugins/web-search.js";
 import { projectExecutionLaneCapability } from "../../capabilities/execution-lane.js";
+import { SETTINGS_CONTRACT_CAPABILITY } from "../../capabilities/settings-contract.js";
 import { judgeSandboxGitPlane, sandboxGitPlanePremisesOf } from "../../sandbox-git-plane.js";
 import { MCP_ASSERTION_HEADER_SENT, MCP_REQUEST_TRANSPORT_KINDS } from "../../mcp-assertion-header.js";
 import { gateCompositeMembers } from "../../capabilities/composite-members.js";
@@ -35,6 +36,7 @@ import * as facts from "../../capability-facts.js";
 import { judgeAutoModeArming } from "../../auto-mode-face.js";
 import { coercePermissionModeStrict, PERMISSION_MODE_WORDS, taskHooksHonored } from "../../task-settings.js";
 import { gatedPrincipal, sendPrincipalRefusal } from "../principal-gate.js";
+import { readAdoptionImportCapability } from "../../adoption/import.js";
 import { headReadOf } from "../../session-incarnation.js";
 import { callerTrust } from "../caller-trust.js";
 import { sessionRulesNamespaceFormsHonored } from "../../session-policy-wire.js";
@@ -95,10 +97,10 @@ export async function handleCapabilities(req, res, match, ctx) {
                     ? {
                         enabled: true,
                         protocolVersion: DEVICE_PROTOCOL_VERSION,
-                        maxInflightPerDevice: deps.config.remoteExec?.provider === "device" ? (deps.config.remoteExec.maxInflightPerDevice ?? 4) : 4,
+                        maxInflightPerDevice: deps.config.remoteExec.provider === "device" ? (deps.config.remoteExec.maxInflightPerDevice ?? 4) : 4,
                         wsPath: DEVICE_WS_PATH,
                         management: facts.deviceManagement(deps).available,
-                        ...(deps.config.remoteExec?.provider === "device" && deps.config.remoteExec.relay.kind === "url" ? { relayUrl: deps.config.remoteExec.relay.url } : {}),
+                        ...(deps.config.remoteExec.provider === "device" && deps.config.remoteExec.relay.kind === "url" ? { relayUrl: deps.config.remoteExec.relay.url } : {}),
                     }
                     : false,
                 sessionEvents: facts.sessionEventStream(deps).available,
@@ -121,6 +123,7 @@ export async function handleCapabilities(req, res, match, ctx) {
                 sharedMemory: facts.sharedMemoryRead(deps).available,
                 principalInboxDelivery: facts.principalInboxDelivery(deps).available,
                 adoption: facts.adoption(deps).available,
+                adoptionImport: await readAdoptionImportCapability(facts.adoptionSessionImport(deps), gatedPrincipal(req, deps.config), deps.config),
                 memoryBundle: facts.memoryBundle(deps).available,
                 memoryCompliance: facts.memoryCompliance(deps).available,
                 memoryOrigin: facts.memoryOrigin(deps).available,
@@ -147,8 +150,9 @@ export async function handleCapabilities(req, res, match, ctx) {
                 scratchpadDir: true,
                 subagentSteer: facts.subagentSteer(deps).available,
                 subagentResume: facts.subagentSteer(deps).available,
-                taskSettings: { permissions: true, permissionMode: true, model: true, outputStyle: true, env: DEPLOYMENT_SHAPE_PREDICATES.callerCwd.holds(deps.config), hooks: taskHooksHonored(deps.config), pluginHooks: taskHooksHonored(deps.config), managedHookGroups: taskHooksHonored(deps.config), httpHookAllowlists: taskHooksHonored(deps.config), tightenOnlySeats: true, approvalFrameFamilies: true },
+                taskSettings: { permissions: true, permissionMode: true, model: true, outputStyle: true, env: DEPLOYMENT_SHAPE_PREDICATES.callerCwd.holds(deps.config), hooks: taskHooksHonored(deps.config), pluginHooks: taskHooksHonored(deps.config), managedHookGroups: taskHooksHonored(deps.config), httpHookAllowlists: taskHooksHonored(deps.config), tightenOnlySeats: true, approvalFrameFamilies: true, autoCompactEnabled: true },
                 settings: { permissions: { allowGrant: true, allowLayer: true, layers: true, layeredAllow: true, callerTrust: callerTrust(req, deps.config).trust } },
+                settingsContract: SETTINGS_CONTRACT_CAPABILITY,
                 permissionModeAuto: {
                     accepted: true,
                     classifierSeat: deps.autoModeFace?.seatMounted === true,
@@ -187,6 +191,7 @@ export async function handleCapabilities(req, res, match, ctx) {
                 mcpProbe: true,
                 mcpAssertionHeaderSent: MCP_ASSERTION_HEADER_SENT,
                 mcpTransportKinds: [...MCP_REQUEST_TRANSPORT_KINDS],
+                engine: { handover: facts.engineHandover(deps).available },
                 mcpElicitation: facts.elicitation(deps).available,
                 askUserQuestion: facts.askUserQuestion(deps).available,
                 toolApproval: facts.toolApproval(deps).available,
@@ -201,6 +206,7 @@ export async function handleCapabilities(req, res, match, ctx) {
                 sessionReadRedaction: true,
                 sideQuery: true,
                 agentRoster: facts.agentRoster(deps).available,
+                projects: facts.projectRegistry(deps).available,
                 retention: retentionAdvertisement(deps.config),
                 peerLane: Boolean(deps.peerDirectory),
                 sessionList: facts.sessionList(deps).available,
@@ -214,6 +220,8 @@ export async function handleCapabilities(req, res, match, ctx) {
                 rewindFiles: Boolean(deps.fileHistoryStore),
                 restoreFiles: Boolean(deps.fileHistoryStore),
                 rewindFilesTo: Boolean(deps.fileHistoryStore && deps.resumeAnchorStore && headReadOf(deps.sessionStorage)),
+                sessionRewindFiles: facts.sessionRewindFiles(deps).available,
+                sessionRewindFilesPreview: facts.sessionRewindFilesPreview(deps).available,
                 fileHistoryCapture: fileHistoryCaptureOf(deps.fileHistoryStore, deps.config.fileHistoryCapture),
                 scheduler: facts.hostScheduler(deps.config).available,
                 sessionSync: facts.sessionSync(deps).available,
@@ -295,6 +303,7 @@ export async function handleCapabilities(req, res, match, ctx) {
                 ...(m.maxTokens ? { maxOutputTokens: m.maxTokens } : {}),
                 ...((levels) => (levels !== undefined ? { supportedEffortLevels: [...levels] } : {}))(reasoningEffortLevelsOf(m)),
                 ...(m.compat !== undefined ? { compat: m.compat } : {}),
+                ...(m.thinkingLevelMap !== undefined ? { thinkingLevelMap: m.thinkingLevelMap } : {}),
                 ...mentionBit(name),
                 routePairing: routePairingOf(deps, name, m),
             }));

package/dist/http/routes/devices.js

@@ -163,7 +163,7 @@ export async function handleDevices(req, res, match, ctx) {
         }
         if ((await readClosedBody(req, res, readJson, [])) === null)
             return;
-        const ttlSeconds = (deps.config.remoteExec?.provider === "device" ? deps.config.remoteExec.enrollTokenTtlSec : undefined) ?? DEFAULT_ENROLL_TOKEN_TTL_SEC;
+        const ttlSeconds = (deps.config.remoteExec.provider === "device" ? deps.config.remoteExec.enrollTokenTtlSec : undefined) ?? DEFAULT_ENROLL_TOKEN_TTL_SEC;
         const issued = await enrollment.issueEnrollToken({ target: domain, createdBy: domain.subject, ttlSeconds });
         if (!issued.ok) {
             sendDeviceRejection(res, issued.reject);

package/dist/http/routes/diagnostics.d.ts

@@ -13,6 +13,7 @@ import { type PostureKnobReading, type PostureSource } from "../../posture-sourc
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { WiringManifest } from "@sema-agent/core";
 import { type StreamApprovalGate, type StreamApprovalGateInput } from "../../tool-approval.js";
+import { verifiedIdentitySource } from "../principal-gate.js";
 import type { RouteCtx, RouteMatch, RouteIdsOf } from "../route-ctx.js";
 /** 流内审批门的读数形:上场即 `"active"`,否则是那**四**个合取项里**第一个**不满足的原因词
  *  (与 `resolveStreamApprovalGate` 同一闭集,词表**取型**自它 ⇒ 增删 reason 在此处自动跟随/编译红;
@@ -82,23 +83,17 @@ export declare function assertStaticWiringConsistent(facts: StaticWiringFacts, l
     warn: (msg: string, meta?: Record<string, unknown>) => void;
 } | undefined): StaticWiringAudit;
 /**
- * [ref]③ clay 裁 (b)(2026-08-12,core [ref]④ + cli [ref]① 双背书):**零凭证 turnkey 形**的
- * loopback 来源门判据(单一属主,端点与测试同吃)。
+ * 诊断面的**远程来源门**(单一属主,端点与测试同吃;[ref]③ clay 裁 (b) 的那只门,7.63.0 起按身份判):远程请求后面没有
+ * **验过的身份**(`verifiedIdentitySource`:service 凭据 / 鉴权桥登录令牌 / 直连门签名令牌)⇒ 拒;本机(loopback)照读。
  *
- * 只在「operator 名单空 ∧ 非多租户 ∧ 全局 service-credential 门也不在场(没配 SERVICE_AUTH_TOKEN /
- * AUTH_TOKENS)」的部署形上判——那正是全局门整个不设、诊断端点此前无认证可读的形。诊断面泄的是装配
- * 拓扑(store 接线/能力位/治理姿态),对误暴露公网端口的 turnkey 机器构成侦察面。(b) 对本机自用零摩擦
- * (壳缺省钉 BIND_HOST=127.0.0.1,local curl 照常),对远程侦察 fail-closed;配了 token 的部署远程读
- * 走认证(全局门),不进本臂。
+ * 名单里的名字、单用户声明放进来的「每个调用方」,都只在这次请求带可验身份时才是身份 —— 没有凭据可验的部署上,主体头是谁都能写的
+ * 字符串,端口误暴露到公网就是侦察面(装配拓扑 / 治理姿态 / 写保护名表)。配了 service 凭据的部署上,到得了这里的请求都过了全局凭据门、
+ * 必然带着验过的身份,本判不咬;不要求静态凭据在场(鉴权桥的登录令牌就是身份)。
  *
- * 判源=TCP 对端地址(`req.socket.remoteAddress`),**非任何头**——XFF 类头在无反代的 turnkey 形上本就
- * 是自造面;有反代的部署必然配 token(反代后 remoteAddress 恒 loopback,门自然放行,语义仍对:该形的
- * 边界由反代+token 承担)。`remoteAddress` 缺席(socket 已断等边缘)⇒ 判拒(fail-closed,安全轴方向)。
+ * 判源 = TCP 对端地址(`req.socket.remoteAddress`),**非任何头**(XFF 类头在无反代形上是自造面;有反代的部署必然配凭据)。
+ * `remoteAddress` 缺席(socket 已断等边缘)⇒ 判拒(fail-closed)。
  */
-export declare function zeroCredentialLoopbackDenied(remoteAddress: string | undefined, config: {
-    authToken?: string;
-    authTokens?: Record<string, string>;
-}): boolean;
+export declare function remoteWithoutVerifiedIdentity(req: IncomingMessage, config: Parameters<typeof verifiedIdentitySource>[1]): boolean;
 export declare function handleDiagnostics(req: IncomingMessage, res: ServerResponse, match: RouteMatch<DiagnosticsRouteId>, ctx: RouteCtx): Promise<void>;
 export declare const DIAGNOSTICS_ROUTES: readonly [{
     readonly id: "diagnostics-wiring";

package/dist/http/routes/diagnostics.js

@@ -95,32 +95,22 @@ export function assertStaticWiringConsistent(facts, logger) {
     }
     return audit;
 }
-export function zeroCredentialLoopbackDenied(remoteAddress, config) {
-    const anyServiceAuth = Boolean(config.authToken) || Object.keys(config.authTokens ?? {}).length > 0;
-    if (anyServiceAuth)
-        return false;
-    return !isLoopbackAddress(remoteAddress);
+export function remoteWithoutVerifiedIdentity(req, config) {
+    return !isLoopbackAddress(req.socket.remoteAddress) && verifiedIdentitySource(req, config) === undefined;
 }
 export async function handleDiagnostics(req, res, match, ctx) {
     const { deps } = ctx;
     switch (match.decl.id) {
         case "diagnostics-wiring": {
-            if (deps.config.operatorPrincipals.length > 0 || deps.config.requirePrincipal) {
-                if (!facts.operatorLane(deps).available) {
-                    sendOperatorPrincipalsRequired(res);
-                    return;
-                }
-                const principal = gatedPrincipal(req, deps.config);
-                if (!explicitOperatorOk(principal, deps.config)) {
-                    sendError(res, 403, "auth.operator_only", "wiring diagnostics are operator-only on a multi-tenant worker");
-                    return;
-                }
-                if (!isLoopbackAddress(req.socket.remoteAddress) && verifiedIdentitySource(req, deps.config) === undefined) {
-                    sendError(res, 403, "auth.loopback_only", "wiring diagnostics on a zero-credential deployment are readable from loopback only — configure SERVICE_AUTH_TOKEN to read remotely");
-                    return;
-                }
+            if (!facts.operatorLane(deps).available) {
+                sendOperatorPrincipalsRequired(res);
+                return;
+            }
+            if (!explicitOperatorOk(gatedPrincipal(req, deps.config), deps.config)) {
+                sendError(res, 403, "auth.operator_only", "wiring diagnostics are operator-only");
+                return;
             }
-            else if (zeroCredentialLoopbackDenied(req.socket.remoteAddress, deps.config)) {
+            if (remoteWithoutVerifiedIdentity(req, deps.config)) {
                 sendError(res, 403, "auth.loopback_only", "wiring diagnostics on a zero-credential deployment are readable from loopback only — configure SERVICE_AUTH_TOKEN to read remotely");
                 return;
             }