@sema-agent/server 7.146.0 → 7.148.0

package/dist/http/retired-skill-manifest.d.ts

@@ -2,7 +2,7 @@
  * 技能上已退役的 `manifest` 键 —— 「一条技能还带它」的**唯一判据**(core 7.41.0 起 `SkillSpec.manifest` 退役,零别名)。
  *
  * 两个读者,同一句话:
- *  · 提交口的顶层技能门(`admission.ts` 的 `validateUserSkills`):带它(任何值)⇒ 点名拒;
+ *  · 提交口的两道技能门(顶层 `skills[i]` 与子代 `agents[a].skills[j]`,同经 `spec-fields.ts` 的 `skillItemIssue` → `namedRefusalOf`):带它(任何值)⇒ 点名拒;
  *  · 随包排空脚本(`scripts/drain-check-local.mjs` 的 `retired-skill-manifest` 判据,经脚本隔壁的编译产物 `dist/http/retired-skill-manifest.js` 取):
  *    升级前停驻、持久化的提交体里仍带它的行,升级后续跑会被引擎按名拒(顶层 `skills[]`)或丢掉那只子代定义(`agents[].skills[]`),运维升级前要能数出来。
  *

package/dist/http/rewind-files-reply.d.ts

@@ -0,0 +1,34 @@
+/**
+ * run 外回退口 `POST /v1/sessions/:id/rewind-files` 的 200 体 —— 引擎 `Runner.rewindFiles` 的结果(`RewindFilesResult`)**原形**,文本叶经出口座出门。
+ *
+ * 规则一句:形照引擎(`dryRun:true` ⇒ `{ preview }`,`null` 仍是 `null`;`dryRun:false` ⇒ `{ restore }` 台账,空数组仍是空数组),每一片自由文本叶只经
+ * {@link seatText} 的一行 —— 被跟踪文件的路径(台账 `filesChanged` / `identicalSkipped` / `refused[].path` / `failed[].path`、预览 `filesChanged`;源头是模型交的
+ * 路径参数)走 `rewind-ledger-path`(不设界:截过的路径就不是那个文件了);拒因 / 故障句(`refused[].reason` / `failed[].reason` / `error.message`)走
+ * `rewind-ledger-reason`;闭集词 / 计数逐字。台账上的店故障(core `FileHistoryError`)按本仓错误体的唯一机读键律出门:引擎的 `code` 成员在 wire 上叫
+ * `errorCode`(值逐字),`message` 经座,`permanence` 逐字 —— 本仓的 wire 上没有叫 `code` 的错误键。两张叶表与故障的三键按 core 型的键穷举 ——
+ * core 给台账 / 统计 / 故障加一格而这里不表态 ⇒ tsc 红;表外的运行期键不出门(按表取键,不展开原对象)。唯一调用方 = `http/routes/sessions.ts` 的 `session-rewind-files` 臂。
+ */
+import type { FileHistoryDiffStats, FileHistoryError, FileHistoryRestoreResult, RewindFilesResult } from "@sema-agent/core";
+/** 台账上的店故障在 wire 上的形:码键 = `errorCode`(本仓错误体的唯一机读键),其余两键同引擎。 */
+export interface RewindLedgerError {
+    readonly errorCode: FileHistoryError["code"];
+    readonly message: string;
+    readonly permanence?: FileHistoryError["permanence"];
+}
+/** 台账在 wire 上的形 = 引擎台账,`error` 换成 {@link RewindLedgerError}。 */
+export type RewindLedgerReply = Omit<FileHistoryRestoreResult, "error"> & {
+    readonly error?: RewindLedgerError;
+};
+/** 200 体在 wire 上的形(引擎 `RewindFilesResult`,台账的 `error` 按 {@link RewindLedgerError})。 */
+export type RewindFilesReply = {
+    readonly dryRun: true;
+    readonly preview: FileHistoryDiffStats | null;
+} | {
+    readonly dryRun: false;
+    readonly restore: RewindLedgerReply & {
+        readonly outcome: "complete" | "partial";
+    };
+};
+/** 200 体(纯数据)。 */
+export declare function buildRewindFilesReply(result: RewindFilesResult): RewindFilesReply;
+//# sourceMappingURL=rewind-files-reply.d.ts.map

package/dist/http/rewind-files-reply.js

@@ -0,0 +1,36 @@
+import { seatText } from "../trace/exit-seat.js";
+function applyLeafTable(obj, table) {
+    const out = {};
+    for (const key of Object.keys(table)) {
+        const v = obj[key];
+        if (v !== undefined && v !== null)
+            out[key] = table[key](v);
+    }
+    return out;
+}
+const pathLeaf = (p) => seatText("rewind-ledger-path", p);
+const reasonLeaf = (t) => seatText("rewind-ledger-reason", t);
+function ledgerErrorOf(e) {
+    return { errorCode: e.code, message: reasonLeaf(e.message), ...(e.permanence !== undefined ? { permanence: e.permanence } : {}) };
+}
+const RESTORE_LEDGER_LEAVES = {
+    outcome: (v) => v,
+    filesChanged: (v) => v.map(pathLeaf),
+    identicalSkipped: (v) => v.map(pathLeaf),
+    refused: (v) => v.map((f) => ({ path: pathLeaf(f.path), reason: reasonLeaf(f.reason), class: f.class })),
+    failed: (v) => v.map((f) => ({ path: pathLeaf(f.path), reason: reasonLeaf(f.reason) })),
+    modeNotPreserved: (v) => v,
+};
+const DIFF_STATS_LEAVES = {
+    filesChanged: (v) => v.map(pathLeaf),
+    insertions: (v) => v,
+    deletions: (v) => v,
+};
+export function buildRewindFilesReply(result) {
+    if (result.dryRun)
+        return { dryRun: true, preview: result.preview === null ? null : applyLeafTable(result.preview, DIFF_STATS_LEAVES) };
+    const { error, ...ledger } = result.restore;
+    const projected = applyLeafTable(ledger, RESTORE_LEDGER_LEAVES);
+    return { dryRun: false, restore: { ...projected, outcome: result.restore.outcome, ...(error !== undefined ? { error: ledgerErrorOf(error) } : {}) } };
+}
+//# sourceMappingURL=rewind-files-reply.js.map

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

@@ -17,9 +17,8 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 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 +35,9 @@ 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";
+import type { KeyCaller } from "../owner-faces.js";
+import type { Subject } from "../owner-brands.js";
 /** 跨域可变状态 = lens1 §C2 实测的那 8 条「运行期登记簿」,一个对象。
  *  [ref]:`cancelledViaVerb`(按 taskId 键控的「这次是取消动词」旁表)删除 —— 中止成因改挂在每条腿自己的
  *  {@link RunAbort} 句柄上(`inflightRuns` 的值),同寿同删,不再有一张与腿不同寿的旁表。 */
@@ -58,11 +60,12 @@ export interface RouteHelpers {
     readRawBody(req: IncomingMessage, max: number): Promise<Buffer>;
     rateLimited(req: IncomingMessage, res: ServerResponse): boolean;
     quotaExceeded(req: IncomingMessage, res: ServerResponse): boolean;
-    leaseDenied(req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+    /** `seat` 在场(提交门之后的调用点)⇒ 拒经出口座写(`submission-exit.ts`:先收场、再写);缺席(提交门之前)⇒ 当场写。下面 `usageWindowDenied` / `admitRun` 同。 */
+    leaseDenied(req: IncomingMessage, res: ServerResponse, seat?: TerminalSeat): Promise<boolean>;
     /**
      * 🔴 **[ref]:按**付费**方(不是请求方)判的成本配额准入 —— {@link quotaExceeded} 的孪生。**
      *
-     * `quotaExceeded` 键在 `gatedPrincipal(req)` = 谁点的按钮;本门键在**这笔钱记谁的账**。两者在自助
+     * `quotaExceeded` 键在 `gatedSubject(req)` = 谁点的按钮;本门键在**这笔钱记谁的账**。两者在自助
      * 场景恒相等,在「显式 operator 代别人动手」的场景不等 —— 那正是配额上限被绕过的那一支。
      * 参数 `owner` 由调用点从**已属主校验过的那一行**取(run 行的 `owner` / checkpoint 的 scope),
      * 本门不自己推身份(推得出来就说明调用点还有第二个身份源,那才是病)。
@@ -78,23 +81,14 @@ export interface RouteHelpers {
      *  「拿自己的额度去烧别人的账」的那一支。同样必须排在 owner 门之后、驱动之前。 */
     ownerLeaseDenied(res: ServerResponse, owner: string | undefined): Promise<boolean>;
     /** [ref]-T1:治理窗 pre-admission(异步 202 车道的唯一 429 出路;key 公式与 core 单源)。 */
-    usageWindowDenied(req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+    usageWindowDenied(req: IncomingMessage, res: ServerResponse, seat?: TerminalSeat): Promise<boolean>;
     /**
      * 在飞 run 并发帽的提交门准入(`RUN_MAX_CONCURRENT*`,缺省关;判据、席位与拒的形全文在 `http/run-concurrency-cap.ts`):放行 ⇒ 席位(登记那一拍与 `finally` 放);
-     * 超帽 ⇒ 已应答 429 + `Retry-After`、回 `undefined`。只挂**新提交**门(`createDurableRun` / `POST /v1/tasks` / `POST /v1/tasks/stream`),
+     * 超帽 ⇒ 已(经出口座)应答 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;
+    admitRun(req: IncomingMessage, res: ServerResponse, seat: TerminalSeat): Promise<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;
-    /** 会话面的属主门(谓词 `sessionOwnerReadable`,[ref]:没有身份边界的部署不钉人,与会话列表同读;非属主 ⇒ 404 `not_found.session` +
-     *  {@link SESSION_NOT_FOUND_MESSAGE},与会话读口的 unknown 臂同码同串 —— G52 [ref] / [ref])。每一个按会话寻址的属主判都走它。
-     *  `cell` = 调用点经 `security.ts` 的 `sessionOwnerCellOf` 读出的那一格([ref]:无主的委派子代 placed 行只对 fleet 调用方放行,判据 `ownerlessRowOpen`)。 */
-    sessionOwnerOk(req: IncomingMessage, res: ServerResponse, cell: SessionOwnerCell): boolean;
-    runSessionAcceptOk(req: IncomingMessage, res: ServerResponse, run: {
-        sessionId: string | null;
-    }, face: string, notFoundError?: string): boolean;
 }
 /** 单域独占状态(lens1 实测 12 条)——不进 registry,跟着各自的域模块走;每个 server 实例一份
  *  (模块级会把 rate-limiter / 缓存跨实例串味,测试里一个进程建几十个 server)。 */
@@ -125,6 +119,8 @@ export interface RouteRequestState {
 }
 /** B4①(命名化):`prepareSpec` 的返回形(tasks.ts/runs.ts 两域共同消费的属性面)——原为 6 成员内联匿名对象。
  *  命名后好处不只是过 B4 门:两个消费域现在都能对同一个符号做 `import type` 标注,而不是各自重推断结构。 */
+/** 提交门之后的拒交给出口座写的那一面(`submission-exit.ts`)。 */
+export type TerminalSeat = Pick<import("../submission-exit.js").SubmissionSeat, "deliverTerminal">;
 export interface PreparedTaskSubmission {
     /** 盖过根的 spec(`http/execution-context.ts` `stampSpecRoot` 是唯一写者):`sessionId` 恒在 = 这次提交的根会话。 */
     spec: RootedTaskSpec;
@@ -170,6 +166,11 @@ export interface PreparedTaskSubmission {
      * 不经提交门的内部车道(`/decide` 的宿主新 turn)铸一只不带标题器的座:不起标题。
      */
     acceptance: import("../run-acceptance.js").RunAcceptance;
+    /**
+     * 这次提交的**出口座**(`submission-exit.ts`):提交门在授权之前铸,授权器登记新行时把候选交给它、受理座挂在它上面。三条提交腿认领赢时交本次 run、
+     * 交出查询责任时标 record,终局应答经 `seat.deliverTerminal` 写,在自己的路径上、终局应答之前 `seat.close()` —— 被拒的提交铸下的会话在应答发出之前撤回。
+     */
+    seat: import("../submission-exit.js").SubmissionSeat;
     /**
      * 这次装配的**宿主租约**:受理漏斗在装配之前开(`peerDesk.lease("fresh")`),装配在它之下登记交给引擎的对端声明;漏斗成功即把它交到这里 ——
      * 拿到本产物的那只函数紧接着写 `try { … } finally { prepared.peerLease.release() }`,其后每个出口(早退、合流败方、建行拒、驱动返回)按构造都放。
@@ -301,7 +302,8 @@ export interface DriveResumeArgs {
     /** 这条腿的部署事实(`leg-facts.ts`):续跑漏斗在复制之前读出的那一份(与 {@link PreparedTaskSubmission.legFacts} 同一律)。读者 = 本腿的 `wiring_manifest.skills` 段与会话行记录座。 */
     legFacts: import("../leg-facts.js").LegFacts | undefined;
     sessionId: string;
-    principal: string | undefined;
+    /** 卡属主的**主体**(分区键;`decodeCheckpointScope(cp.scope)` 恢复):ALS 与行属主读它,付费方两道门读它背后的人(`personOf`)。 */
+    subject: string | undefined;
     fleetScope: string;
     taskConfig: Omit<TaskSpec, "objective" | "sessionId">;
     resumeObjective: string;
@@ -312,7 +314,8 @@ export interface DriveResumeArgs {
      * 它只是分类:位由受理点与终局体两个边界按它铸,从不只凭这一句声明铸;缺席的取消出口(`checkpoint.resume_aborted` / 抛出臂)不铸。
      */
     commitment: GateCommitment;
-    verifyRounds: VerifyRoundsSpec | undefined;
+    /** 续跑腿接着跑哪一只组合入口(verify 验证门 / cascade 梯子;缺席 = 普通腿);读法的唯一属主 = `resume-composition.ts`。 */
+    composition: import("./resume-composition.js").ResumeComposition | undefined;
     /**
      * **R-1**(车CJ 收车档 §10 R-1;[ref] 批落地)—— 本条 resume 腿**装配期**铸下的用户面通告
      * (`PreparedTaskSubmission.engineNotices` 的 resume 孪生;今天唯一一族:`mcp.injection_dropped`)。
@@ -355,7 +358,7 @@ export interface DriveResumeArgs {
      *  markResuming CAS(409 `conflict.not_resumable`)、pre-CAS CheckpointError(绑定不符 409 /
      *  卡不在 404)。异步化的只有模型往返段。
      *
-     *  ⚠️ **verify 腿(`verifyRounds` 在场)不受本位影响**:core 的 `resumeWithVerification` 是一次整包
+     *  ⚠️ **组合腿(`composition` 在场:verify / cascade)不受本位影响**:core 的 `resumeWithVerification` 是一次整包
      *  await,没有「CAS 已过、模型还没跑」这个缝可停 —— 在那条臂上提前受理就等于把绑定判别也异步化了
      *  (那是决策证明的一部分,不能丢)。故它维持同步长调用形,如实登记在 CHANGELOG/契约文档。
      *
@@ -421,6 +424,7 @@ export interface PreparedPlanReview {
     readonly sessionId: string;
     readonly token: CheckpointToken;
     readonly cp: Checkpoint;
+    /** 这条决断唯一的一次 ctx 读,**已盖过**续跑请求的重述键(缺席 = 存量体原样):存体预判判的、驱动段重建与写回读的都是这一份。 */
     readonly ctx: CheckpointCtx;
 }
 /** 提交/续跑「腿」= 跨域共享的**有状态**长流程(不像 {@link RouteHelpers} 那样只依赖 deps/config:它们要写
@@ -459,25 +463,16 @@ 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, 
     /** [ref]:调用方已验身份的裁定 —— stale 臂铸 `currentPending` 指路键前在被读回的行上重跑 decide 门
      *  同一属主判(缺席 ⇒ 恒不造键;判据属主=server.ts 铸键点注)。 */
-    decider?: {
-        principal?: string;
-        explicitOperator: boolean;
-    }, 
+    decider?: KeyCaller, 
     /** 续跑请求的重述键(`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 守卫 + 行级属主复核 + 驱动)。 */
@@ -486,14 +481,13 @@ export interface RouteLegs {
     acceptEarly?: boolean, 
     /** [ref]②([ref]):调用方已验身份的裁定 —— 腿内在被真正载入的 checkpoint 行上重跑属主判
      *  ([ref] R3 同形;缺席 = 匿名 dev 部署,不咬)。 */
-    decider?: {
-        principal?: string;
-        explicitOperator: boolean;
-    }, 
+    decider?: KeyCaller, 
     /** 续跑请求的重述键(同 {@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: Subject | undefined, req: IncomingMessage | undefined, 
     /** [ref] 件 S-1:透传给 {@link DriveResumeArgs.acceptEarly}(200 受理语义)。HTTP `/wake` 腿传 `true`
      *  —— 本腿走 `mintFreshRun`,受理体里的 `taskId` 因此是**新铸的**那个(壳的 poll 锚)。 */
     acceptEarly?: boolean, 
@@ -517,12 +511,11 @@ export interface RouteLegs {
     }, 
     /** [ref]②([ref]):调用方已验身份的裁定(直连门 = HMAC 验出的 principal)—— 属主轻读与行级属主复核
      *  ([ref] R3 同形;缺席 = 匿名 dev 部署,不咬)。 */
-    decider?: {
-        principal?: string;
-        explicitOperator: boolean;
-    }, 
+    decider?: KeyCaller, 
     /** [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;
@@ -540,9 +533,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;
 }
@@ -694,7 +685,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 腿本身(关流 = 断连语义),照旧算在飞。漏标一条订阅的方向是**多算在飞**(排空多等),不是少等。
@@ -740,6 +731,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])。
  *
@@ -767,7 +776,7 @@ export declare const RUN_NOT_FOUND_MESSAGE = "run not found \u2014 the id belong
  *
  * 为什么是常量不是各点字面量:这句话要在**每一个**会话面的「不存在」臂与「非属主」臂上逐字节同串(G52 [ref] /
  * [ref] —— 两臂差一个码或一个字就是单端点内的存在性 oracle)。十余个出站点各抄一份,漂开的那天没有任何东西会说话;
- * 走一只常量 + `runOwnerOk(..., "session")` 的会话拼法,「改一处」就是改全域。
+ * 走一只常量 + `admitRunRow(..., "session")` 的会话拼法,「改一处」就是改全域。
  */
 export declare const SESSION_NOT_FOUND_MESSAGE = "session not found";
 /** [ref] 前缀=域判别子既成契约:a\* 与 wa\* 形 id 给任务句柄读腿 / journal 指路;其余给 {@link RUN_NOT_FOUND_MESSAGE}。 */

package/dist/http/route-table.js

@@ -19,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";
@@ -81,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/a2a-serve.d.ts

@@ -1,8 +1,10 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { A2ATaskState } from "@sema-agent/core";
-import type { A2aServeConfig } from "../../config-types.js";
+import type { A2aServeConfig, A2aServeSkill } from "../../config-types.js";
 import { type RunRecord } from "../../plugins/store-contracts.js";
 import type { RouteCtx, RouteMatch, RouteIdsOf } from "../route-ctx.js";
+import type { RunStore } from "../../plugins/store-backend.js";
+import type { Person } from "../../owner-brands.js";
 /** 本实现说的 A2A 协议版本 —— 卡的 `protocolVersion` 与每条 RPC 响应的 `a2a-version` 头同源(单点)。 */
 export declare const A2A_PROTOCOL_VERSION = "1.0";
 /** 版本头名。**读**请求侧的它只是诊断材料(开集容忍:认识与否都照常答),**写**响应侧的它是我们自报
@@ -15,17 +17,38 @@ interface A2aCardSkill {
     name: string;
     description?: string;
 }
-/** A2A AgentCard 的 server 铸面。**具名字段 + 允许未来 additive**(设计稿 §4-5 数据形扩展槽)。 */
+/** A2A AgentCard 的 server 铸面 —— **sema 方言**:字段族是 A2A v0.3 的(顶层 `url` + `preferredTransport`,方法名 v0.3 拼法),
+ *  标签 `protocolVersion: "1.0"` 跟随 core 客户端腿;**不是**完整的 v0.3 AgentCard(v0.3 要的 `version` / `capabilities` /
+ *  `defaultInputModes` / `defaultOutputModes` / 技能 `tags` / `securitySchemes` 本卡都没有 —— 已声明的方言差异,契约附录 C.1 列全)。
+ *  **具名字段 + 允许未来 additive**(设计稿 §4-5 数据形扩展槽)。公开卡与扩展卡**同形**,只差 `skills` 的过滤。 */
 interface A2aAgentCard {
     name: string;
     description?: string;
     protocolVersion: string;
     url: string;
     preferredTransport: "JSONRPC";
+    /** 扩展卡方法在不在方法表里(**派生**,不是常量也不是配置)⇒ 与配没配 `audience` 无关:匿名读者从卡上读不出「这里有隐藏技能」。 */
+    supportsAuthenticatedExtendedCard: boolean;
     skills: A2aCardSkill[];
 }
-/** 配置 → 卡(纯投影,零 I/O、零存量读)。`build*`:返回纯数据。 */
-export declare function buildAgentCard(serve: A2aServeConfig): A2aAgentCard;
+/** (配置, 这次请求验过的人, 方法表) → 卡(纯投影,零 I/O、零存量读)。`build*`:返回纯数据。
+ *  `reader` 缺席 = 公开卡;在场 = 扩展卡(按 {@link skillsOfferedTo} 过滤)。旗读方法表(调用点恒传 {@link A2A_METHODS})。 */
+export declare function buildAgentCard(serve: A2aServeConfig, reader: Person | undefined, methods: ReadonlyMap<string, A2aMethodHandler>): A2aAgentCard;
+/** sema 方言扩展卡的方法名(A2A v0.3 §7.10 的拼法,与 `message/send` / `tasks/get` 同一方言;不加 1.0 别名 —— 一种方言一个名字)。 */
+export declare const EXTENDED_CARD_METHOD = "agent/getAuthenticatedExtendedCard";
+/**
+ * 🔴 **发布规则(唯一谓词)**:提供给 `reader` 的技能 = 没写 `audience` 的技能 ∪ `audience` 含这个人的技能(声明序,只滤不排)。
+ * 三处同读 —— 公开卡(`reader` 缺席)、扩展卡、`message/send` 的 `sema.skillId` 选择 ⇒ **看得见 ⇔ 点得中**;本文件读
+ * `serve.skills` 的只有这一处。
+ *
+ * **发布 ≠ 授权**:它决定这条技能对谁公告、谁能按 id 点名,**不**决定谁能跑它背后的场景。场景的唯一授权门是场景门
+ * (中心白名单,只在接了中心时存在);不读技能的入口(不带 `sema.skillId` 走指派链 / 映射到同一场景的公开技能 /
+ * 原生提交族 `POST /v1/runs` · `POST /v1/tasks` · `POST /v1/tasks/stream` 体里的 `scenario`)都不经过本谓词。
+ *
+ * 形参收**验过的人**那只品牌:只带 service 凭据(含代部署本人)的请求没有人 ⇒ 只得公开技能;fleet 资格与运维名册**不**扩大投影 ——
+ * 这里不读它们,运维照他自己这个人投影(运维不提权、fleet 不算)。
+ */
+export declare function skillsOfferedTo(serve: A2aServeConfig, reader: Person | undefined): readonly A2aServeSkill[];
 /**
  * 域入口①:公开发现面。**位置即契约** —— 必须挂在 `server.ts` 的全局 service-credential 门**之前**
  * (R-11「公网匿名可发现」;挂在门后等于要凭据才能发现,协商第一步就断)。
@@ -55,7 +78,22 @@ export declare const A2A_TASK_NOT_FOUND_MESSAGE = "task not found";
  * 而那个决议走的是持久审批口、不是一条回信 —— 与 core 对自己 `parked` 行的裁词同源。A2A 调用方因此
  * **不能**靠再发一条 message 解开它(附录 C.3 的表里成文写着这句)。
  */
-export declare function a2aStateForRun(run: Pick<RunRecord, "status" | "errorCode">, stale: boolean): A2ATaskState;
+export declare function a2aStateForRun(run: Pick<RunRecord, "status" | "errorCode">): A2ATaskState;
+/** 一个方法处理器。返回 `result`(被包进 JSON-RPC 成功体)、返回 `undefined`(= 已自行应答)或抛 {@link RpcError}。 */
+type A2aMethodHandler = (args: {
+    req: IncomingMessage;
+    res: ServerResponse;
+    ctx: RouteCtx;
+    params: Record<string, unknown>;
+    serve: A2aServeConfig;
+    /** 事实 `a2aServe` 的见证:两只方法都站在这只 durable run 店上(无店 ⇒ 路由层已 404,走不到方法)。 */
+    runStore: RunStore;
+}) => Promise<unknown>;
+/**
+ * 技能选择拒句(**常量**,零技能 id):点名一条没声明的技能与点名一条没发布给你的技能,拒体逐字节相同 —— 同一个 throw 点、同一句话。
+ * 回显输入的 id 会把「这个 id 在这台部署上有没有含义」交给调用方比对(拼错的调用方看不到回显:它能看的技能名单就在它拉得到的卡上)。
+ */
+export declare const A2A_UNOFFERED_SKILL_MESSAGE = "unknown skill id \u2014 params.message.metadata[\"sema.skillId\"] does not name a skill offered to this caller; the skills a caller can name are the ones on the agent card it can read (the public card, or the authenticated extended card)";
 /**
  * 域入口②:JSON-RPC 端点。**位置即契约** —— 挂在全局 service-credential 门**之后**(R-11「持服务凭据
  * 才可调」),且在 drain / model-roster-pending 两道 503 门之后(`/v1/a2a` 进 `isBillableSubmitPath`: