@sema-agent/server 7.146.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` 的值),同寿同删,不再有一张与腿不同寿的旁表。 */
@@ -421,6 +422,7 @@ export interface PreparedPlanReview {
     readonly sessionId: string;
     readonly token: CheckpointToken;
     readonly cp: Checkpoint;
+    /** 这条决断唯一的一次 ctx 读,**已盖过**续跑请求的重述键(缺席 = 存量体原样):存体预判判的、驱动段重建与写回读的都是这一份。 */
     readonly ctx: CheckpointCtx;
 }
 /** 提交/续跑「腿」= 跨域共享的**有状态**长流程(不像 {@link RouteHelpers} 那样只依赖 deps/config:它们要写
@@ -459,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, 
@@ -477,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 守卫 + 行级属主复核 + 驱动)。 */
@@ -493,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, 
@@ -522,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;
@@ -540,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;
 }
@@ -694,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 腿本身(关流 = 断连语义),照旧算在飞。漏标一条订阅的方向是**多算在飞**(排空多等),不是少等。
@@ -740,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

@@ -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/approvals-assistant.js

@@ -32,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";
@@ -701,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;
@@ -725,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;
         }
@@ -893,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,
@@ -933,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/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";
@@ -96,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,
@@ -151,6 +152,7 @@ export async function handleCapabilities(req, res, match, ctx) {
                 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, 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,
@@ -204,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,
@@ -217,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,
@@ -298,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/memory-origin.d.ts

@@ -105,7 +105,7 @@ export declare function buildClearanceRowWire(r: OriginClearanceRow): {
     requestId: string;
     reason: string;
     at: number;
-    status: "done" | "failed" | "pending";
+    status: "done" | "pending" | "failed";
     originUnknownKeys?: string[] | undefined;
     clearanceId: string;
     entryId: string;

package/dist/http/routes/notify-wake.js

@@ -119,7 +119,8 @@ export async function handleNotifyWake(req, res, match, ctx) {
                 return;
             }
             const restatement = readResumeRestatement(wakeBody);
-            const out = await resumeWake(wakeSession, wakeBody.message, principal, req, true, undefined, undefined, restatement);
+            const message = typeof wakeBody.message === "string" ? { text: wakeBody.message, trusted: false } : undefined;
+            const out = await resumeWake(wakeSession, message, principal, req, true, undefined, undefined, restatement);
             sendResumeOutcome(res, out, deps.logger);
             return;
         }

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

@@ -0,0 +1,70 @@
+/**
+ * 项目登记簿的**读面** —— `GET /v1/projects`、`GET /v1/projects/:id`。
+ *
+ * ## 律(三句)
+ *  · **一个项目 = settings-schema 的一只 `ProjectRegistration`**:形与判官只在 settings-schema;本仓把判过的登记原样放在 `config.projects` 一张表里
+ *    (`web-admin-client/apply-effective.ts` 的 stage 是唯一写者),本面只读那一张。行 = `{ id, …登记的原键原名 }` —— 不铸 `name` / `repos` /
+ *    `createdAt` 之类的别名(端侧要别的叫法自己投影),逐键处置在 {@link PROJECT_ROW_DISPOSITIONS} 一张表里(settings-schema 给登记加键 ⇒ 这里 tsc 红,
+ *    先表态再上 wire)。
+ *  · **登记簿只由配置中心下发**:settings-schema 的本地读取集不收 `projects` 域 ⇒ 没有中心腿在应用配置的部署上没有登记簿 —— 两口 501
+ *    `capability.unavailable`,能力位 `capabilities.projects`(布尔)读同一只事实(`capability-facts.ts` 的 `projectRegistry`)答 `false`;
+ *    有登记簿时答 `true`。本面不开写动词(写到哪里由另一张设计定;写面到货时另立一位,本位不改义)。
+ *  · **可见性 fail-closed**:身份判在登记簿在场判**之前**(否则「这台有没有登记簿」先于 401 泄出去);fleet 调用方(`fleetViewOf` 读档)看全部;
+ *    带验过主体的调用方只看 `registeredBy` 恰是自己的登记;看不见的与不存在的同码同句(404 `not_found.project`,不给存在性预言机)。
+ *
+ * 归档:`archivedAt` 在场 = 已归档。列表缺省不列,`?archived=true` 只列已归档的,`?archived=false` 与缺省同;单项读不论归档与否都答(会话行引用它)。
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { ProjectRegistration } from "@sema-agent/settings-schema";
+import type { RouteCtx, RouteMatch, RouteIdsOf } from "../route-ctx.js";
+/** 404 的唯一句(不存在与看不见同句)。 */
+export declare const PROJECT_NOT_FOUND_MESSAGE = "no such project";
+/** 投影根:这只登记的 id(登记簿的键 —— 不是登记的成员)。 */
+interface ProjectRowRoot {
+    readonly id: string;
+}
+/**
+ * 项目行的**逐键处置**(表序 = 出口序)。登记的每个键原样出门;`contextItems` 逐条按成员处置(闭集三形,成员同为 `kind` / `value`)。
+ * `id` 是本面铸的唯一键:登记簿的键,行上要有它才能回指 `GET /v1/projects/:id` 与提交体 `projectId`。
+ */
+export declare const PROJECT_ROW_DISPOSITIONS: {
+    readonly id: {
+        readonly mint: (_reg: ProjectRegistration, root: ProjectRowRoot) => string;
+    };
+    readonly displayName: "forward";
+    readonly goal: "forward";
+    readonly contextItems: {
+        readonly nested: {
+            readonly kind: "forward";
+            readonly value: "forward";
+        };
+        readonly rows: "each";
+    };
+    readonly gitRemotes: "forward";
+    readonly defaultScopes: "forward";
+    readonly notes: "forward";
+    readonly icon: "forward";
+    readonly color: "forward";
+    readonly registeredBy: "forward";
+    readonly registeredAt: "forward";
+    readonly archivedAt: "forward";
+};
+/** 项目行的键全集(处置表的键 = wire 上可能出现的每一个键;自铸登记表 `trace/self-minted-wire.ts` 的 `projectRowKey` 按它 `satisfies`)。 */
+export type ProjectRowKey = keyof typeof PROJECT_ROW_DISPOSITIONS;
+/** 一只登记 → wire 行(唯一投影)。 */
+export declare function projectRowOf(id: string, registration: ProjectRegistration): Record<string, unknown>;
+export declare function handleProjects(req: IncomingMessage, res: ServerResponse, match: RouteMatch<ProjectsRouteId>, ctx: RouteCtx): Promise<void>;
+export declare const PROJECTS_ROUTES: readonly [{
+    readonly id: "projects-list";
+    readonly path: "/v1/projects";
+    readonly methods: readonly ["GET"];
+}, {
+    readonly id: "project-get";
+    readonly pattern: RegExp;
+    readonly label: "/v1/projects/:id";
+    readonly methods: readonly ["GET"];
+}];
+/** 本域可分派行的 `id` 闭集。 */
+export type ProjectsRouteId = RouteIdsOf<typeof PROJECTS_ROUTES>;
+export {};
+//# sourceMappingURL=projects.d.ts.map

package/dist/http/routes/projects.js

@@ -0,0 +1,86 @@
+import { PROJECT_ID_REGEX } from "@sema-agent/core";
+import { sendJson, sendError } from "../send.js";
+import { fleetViewOf, sendUnauthorized } from "../principal-gate.js";
+import { assertNever } from "../route-ctx.js";
+import * as facts from "../../capability-facts.js";
+import { projectByTable } from "../../trace/projection-table.js";
+export const PROJECT_NOT_FOUND_MESSAGE = "no such project";
+export const PROJECT_ROW_DISPOSITIONS = {
+    id: { mint: (_reg, root) => root.id },
+    displayName: "forward",
+    goal: "forward",
+    contextItems: { nested: { kind: "forward", value: "forward" }, rows: "each" },
+    gitRemotes: "forward",
+    defaultScopes: "forward",
+    notes: "forward",
+    icon: "forward",
+    color: "forward",
+    registeredBy: "forward",
+    registeredAt: "forward",
+    archivedAt: "forward",
+};
+export function projectRowOf(id, registration) {
+    return projectByTable("project", PROJECT_ROW_DISPOSITIONS, registration, { id });
+}
+function readArchivedQuery(raw) {
+    switch (raw) {
+        case null:
+        case "false":
+            return false;
+        case "true":
+            return true;
+        default:
+            return "invalid";
+    }
+}
+export async function handleProjects(req, res, match, ctx) {
+    const { deps } = ctx;
+    const { safeDecode } = ctx.helpers;
+    const { fleetWide, gateOwner } = fleetViewOf(req, deps, "read");
+    if (!fleetWide && gateOwner === null) {
+        sendUnauthorized(res, "identity");
+        return;
+    }
+    const registry = facts.projectRegistry(deps);
+    if (!registry.available) {
+        sendError(res, 501, "capability.unavailable", "the project registry is not available on this deployment: projects are published only by the configuration center, and no center configuration is applied here");
+        return;
+    }
+    const visible = (registration) => fleetWide || registration.registeredBy === gateOwner;
+    switch (match.decl.id) {
+        case "projects-list": {
+            const archived = readArchivedQuery(new URLSearchParams(match.search).get("archived"));
+            if (archived === "invalid") {
+                sendError(res, 400, "request.query_invalid", "archived must be `true` or `false`");
+                return;
+            }
+            const projects = Object.entries(registry.registry)
+                .filter(([, registration]) => visible(registration) && (registration.archivedAt !== undefined) === archived)
+                .map(([id, registration]) => projectRowOf(id, registration));
+            sendJson(res, 200, { projects });
+            return;
+        }
+        case "project-get": {
+            const raw = safeDecode(match.params.projectId);
+            if (raw === null || !PROJECT_ID_REGEX.test(raw)) {
+                sendError(res, 400, "request.id_invalid", "invalid project id (must be a canonical uuid)");
+                return;
+            }
+            const id = raw.toLowerCase();
+            const registration = Object.hasOwn(registry.registry, id) ? registry.registry[id] : undefined;
+            if (registration === undefined || !visible(registration)) {
+                sendError(res, 404, "not_found.project", PROJECT_NOT_FOUND_MESSAGE);
+                return;
+            }
+            sendJson(res, 200, projectRowOf(id, registration));
+            return;
+        }
+        default:
+            return assertNever(match.decl.id);
+    }
+}
+export const PROJECTS_ROUTES = [
+    { id: "projects-list", path: "/v1/projects", methods: ["GET"] },
+    { id: "project-get", pattern: /^\/v1\/projects\/(?<projectId>[^/]+)$/, label: "/v1/projects/:id", methods: ["GET"] },
+];
+//# sourceMappingURL=projects.js.map

package/dist/http/routes/rules.js

@@ -142,6 +142,10 @@ export async function handleRules(req, res, match, ctx) {
                     logger.info("local rule import tightening write failed", { detail: prepared.detail, committed: prepared.committed });
                     sendRuleWriteFailure(res, "import-tightening", prepared.committed);
                     return;
+                case "record-store-refused":
+                    logger.info("local rule import record store refused", { detail: prepared.detail, committed: prepared.committed });
+                    sendRuleWriteFailure(res, "import-record", prepared.committed);
+                    return;
                 default: {
                     const unknown = prepared;
                     throw new Error(`unknown local import refusal: ${JSON.stringify(unknown)}`);
@@ -189,8 +193,19 @@ export async function handleRules(req, res, match, ctx) {
         }
         const prepared = await lane.prepareImport(principal, parsed.data.layers);
         if (!prepared.ok) {
-            sendError(res, 413, "request.payload_too_large", "too many allow entries across the submitted settings layers");
-            return;
+            switch (prepared.reason) {
+                case "too-many-candidates":
+                    sendError(res, 413, "request.payload_too_large", "too many allow entries across the submitted settings layers");
+                    return;
+                case "record-store-refused":
+                    logger.info("rule import record store refused", { detail: prepared.detail, committed: prepared.committed });
+                    sendRuleWriteFailure(res, "import-record", prepared.committed);
+                    return;
+                default: {
+                    const unknown = prepared;
+                    throw new Error(`unknown rule import refusal: ${JSON.stringify(unknown)}`);
+                }
+            }
         }
         sendJson(res, 200, { preview: prepared.preview, ...(prepared.ticket !== undefined ? { ticket: prepared.ticket, expiresAtMs: prepared.expiresAtMs } : {}) });
         return;
@@ -306,6 +321,19 @@ function sendRuleWriteFailure(res, verb, committed) {
                     throw new Error(`unknown rule-write committed word: ${JSON.stringify(unknownWord)}`);
                 }
             }
+        case "import-record":
+            switch (committed) {
+                case "no":
+                    sendError(res, 503, "state.rule_write_failed", "the import's approval record could not be created (no ticket was issued and no allow rule was written; deny / ask rows of a local batch may already be in force) — send the same request again", { committed });
+                    return;
+                case "unknown":
+                    sendError(res, 503, "state.rule_write_failed", "the import's approval record may or may not have been created (no ticket was issued and no allow rule was written; deny / ask rows of a local batch may already be in force) — send the same request again", { committed });
+                    return;
+                default: {
+                    const unknownWord = committed;
+                    throw new Error(`unknown rule-import committed word: ${JSON.stringify(unknownWord)}`);
+                }
+            }
         case "revoke":
             switch (committed) {
                 case "no":

package/dist/http/routes/runs.js

@@ -440,10 +440,10 @@ export async function handleRuns(req, res, match, ctx) {
         const priority = body.priority;
         const steerIdemRaw = headerStr(req.headers["idempotency-key"]);
         const messageId = steerIdemRaw ? `idem-${idemKeyOf(steerIdemRaw, idemCallerOf(req, ctx), "run").slice(0, 32)}` : uuidv7();
-        const trusted = explicitOperatorOk(principal, deps.config);
+        const operator = explicitOperatorOk(principal, deps.config);
         const steerInput = () => ({
             text,
-            trusted,
+            trusted: false,
             inputId: messageId,
             ...(priority !== undefined ? { priority } : {}),
         });
@@ -462,7 +462,7 @@ export async function handleRuns(req, res, match, ctx) {
             sendError(res, 404, "not_found.run", runNotFoundMessage(taskId));
             return;
         }
-        if (!trusted && !runOwnerOk(req, res, run.owner))
+        if (!operator && !runOwnerOk(req, res, run.owner))
             return;
         if (!runSessionAcceptOk(req, res, run, "run.steer"))
             return;
@@ -505,7 +505,7 @@ export async function handleRuns(req, res, match, ctx) {
             if (acceptance === "refused")
                 return;
             try {
-                await relayAcceptedInput(deps, acceptance, () => live.steer(text, { trusted, inputId: messageId, ...(priority !== undefined ? { priority } : {}) }));
+                await relayAcceptedInput(deps, acceptance, () => live.steer(text, { trusted: false, inputId: messageId, ...(priority !== undefined ? { priority } : {}) }));
                 sendJson(res, 200, { taskId, status: "running", delivery: "applied", messageId, ...(priority ? { priority } : {}) });
                 return;
             }
@@ -765,10 +765,10 @@ export async function handleRuns(req, res, match, ctx) {
         const interruptIdemRaw = headerStr(req.headers["idempotency-key"]);
         const interruptInputId = interruptIdemRaw ? `idem-${idemKeyOf(interruptIdemRaw, idemCallerOf(req, ctx), "run").slice(0, 32)}` : uuidv7();
         const interruptMessageId = interruptInputId;
-        const trusted = explicitOperatorOk(principal, deps.config);
+        const operator = explicitOperatorOk(principal, deps.config);
         if (!interruptBare) {
             try {
-                validatePendingSteer({ text, trusted, inputId: interruptInputId });
+                validatePendingSteer({ text, trusted: false, inputId: interruptInputId });
             }
             catch (e) {
                 if (e instanceof CheckpointError && e.code === "steering.invalid_content") {
@@ -783,7 +783,7 @@ export async function handleRuns(req, res, match, ctx) {
             sendError(res, 404, "not_found.run", runNotFoundMessage(taskId));
             return;
         }
-        if (!trusted && !runOwnerOk(req, res, run.owner))
+        if (!operator && !runOwnerOk(req, res, run.owner))
             return;
         if (!runSessionAcceptOk(req, res, run, "run.interrupt"))
             return;
@@ -838,7 +838,7 @@ export async function handleRuns(req, res, match, ctx) {
         if (acceptance === "refused")
             return;
         try {
-            await relayAcceptedInput(deps, acceptance, () => liveStream.steer(text, { trusted, priority: "now", ...(interruptInputId !== undefined ? { inputId: interruptInputId } : {}) }));
+            await relayAcceptedInput(deps, acceptance, () => liveStream.steer(text, { trusted: false, priority: "now", ...(interruptInputId !== undefined ? { inputId: interruptInputId } : {}) }));
         }
         catch (e) {
             const code = e.code;

package/dist/http/routes/session-sync.js

@@ -38,6 +38,21 @@ export function createSessionSyncLocal() {
     };
     return { pendingStagings, importLeases, touchImportLease, cleanupStaging };
 }
+async function firstPhaseRefusal(sessionStorage, sessionId, relation, consented) {
+    if (consented || (relation !== "fork" && relation !== "stale"))
+        return undefined;
+    if (sessionStorage.assertArchiveAnonymous !== undefined && (await readSessionAgent(sessionStorage, sessionId)) === undefined) {
+        try {
+            await sessionStorage.assertArchiveAnonymous(sessionId);
+        }
+        catch (e) {
+            if (e instanceof StampedSessionArchiveError)
+                return { kind: "stamped", error: e };
+            throw e;
+        }
+    }
+    return { kind: "needs_consent" };
+}
 export async function handleSessionSync(req, res, match, ctx) {
     const { deps } = ctx;
     const { readJson, readRawBody, safeDecode, rateLimited } = ctx.helpers;
@@ -358,16 +373,12 @@ export async function handleSessionSync(req, res, match, ctx) {
                 const anchors = anchorsRead.anchors;
                 const dstIds = (await sessionStorage.listEntryIds?.(sessionId)) ?? null;
                 const relA = classifySyncRelationshipByIds(entryIds, dstIds);
-                if ((relA.relation === "fork" || relA.relation === "stale") && resolution !== "overwrite-dst") {
-                    if (sessionStorage.assertArchiveAnonymous !== undefined && (await readSessionAgent(sessionStorage, sessionId)) === undefined) {
-                        try {
-                            await sessionStorage.assertArchiveAnonymous(sessionId);
-                        }
-                        catch (e) {
-                            if (e instanceof StampedSessionArchiveError && sendSessionError(res, e, "import"))
-                                return;
-                            throw e;
-                        }
+                const refusalA = await firstPhaseRefusal(sessionStorage, sessionId, relA.relation, resolution === "overwrite-dst");
+                if (refusalA !== undefined) {
+                    if (refusalA.kind === "stamped") {
+                        if (sendSessionError(res, refusalA.error, "import"))
+                            return;
+                        throw refusalA.error;
                     }
                     sendError(res, 409, "conflict", "sync conflict", { relation: relA });
                     return;
@@ -683,6 +694,12 @@ export async function handleSessionSync(req, res, match, ctx) {
                 }
                 const dst = await sessionStorage.exportEntries(sessionId);
                 const relation = classifySyncRelationshipByIds(body.entryIds, dst ? dst.map((e) => e.id) : null);
+                const refusal = await firstPhaseRefusal(sessionStorage, sessionId, relation.relation, false);
+                if (refusal?.kind === "stamped") {
+                    if (sendSessionError(res, refusal.error, "import"))
+                        return;
+                    throw refusal.error;
+                }
                 sendJson(res, 200, relation);
                 return;
             }