@sema-agent/server 7.137.0 → 7.138.0

package/dist/plugins/worktree-isolation.js

@@ -31,7 +31,7 @@ export function withWorktreeIsolation(baseFactory, opts) {
             return baseFactory(ctx);
         }
         let innerDestroy;
-        const { env, worktreeDir } = await serialize(() => addWorktree(opts.baseEnvForGit, {
+        const { env, worktreeDir, baseSha } = await serialize(() => addWorktree(opts.baseEnvForGit, {
             repoRoot,
             sessionId: ctx.sessionId,
             rootEnvAt: async (dir) => {
@@ -43,12 +43,6 @@ export function withWorktreeIsolation(baseFactory, opts) {
             },
             ...(opts.commit ? { commit: opts.commit } : {}),
         }));
-        let baseSha;
-        {
-            const r = await opts.baseEnvForGit.exec("git rev-parse HEAD", { cwd: worktreeDir });
-            if (r.ok && r.value.exitCode === 0)
-                baseSha = r.value.stdout.trim();
-        }
         const isChanged = async () => {
             const status = await opts.baseEnvForGit.exec("git status --porcelain", { cwd: worktreeDir });
             if (!status.ok || status.value.exitCode !== 0)

package/dist/project-identity.d.ts

@@ -4,19 +4,6 @@ import { type ProjectLayerIdentity } from "./project-layer-key.js";
 export type { MemoryProjectKey };
 /** 本仓会说的缺席词。`not_git` 刻意排除:裁 D 起非 git 目录按目录键控,不是缺席(core 闭集仍收它,本仓不铸)。 */
 export type ProjectIdentityAbsentReason = Exclude<MemoryProjectKeyAbsentReason, "not_git">;
-/** 一个任务根的项目身份:canonical 项目根,或说得出理由的缺席。 */
-export type ProjectIdentity = {
-    readonly root: string;
-} | {
-    readonly absent: ProjectIdentityAbsentReason;
-};
-/**
- * 任务根 → 项目身份([ref] 四例;见文件头)。纯文件系统读,零子进程。
- * `taskRoot` 必须是**本进程读得到**的路径(调用方按车道判:根在沙箱/设备盘上就别调,直接给 `unreadable`)。
- *
- * 一次向上走,规则三条按优先序:最近的 `.git`(① ② ③)> 链上最近的裸仓布局(④ bare)> 非 git 按目录键控(④)。
- */
-export declare function resolveProjectIdentity(taskRoot: string): ProjectIdentity;
 /**
  * 退役 `repo:` 键的**唯一**铸点([ref] ①:`repo:` + sha256 hex 前 24;`root` 为 realpath 字符串,不加尾斜杠、不折大小写)。
  * [ref] 起它只是一次性迁移的来源(`memory-project-layer.ts` 把这一层的条目折进新键;窗见 `plugins/one-time-migrations.ts` 登记表)。
@@ -39,7 +26,7 @@ export declare function assertProjectLayerOwnable(scope: string, envName: string
 export declare function normalizeGitRemoteUrl(url: string): string | undefined;
 /**
  * 任务根 → 项目层身份([ref]):当前档(`r` 优先,没有 origin 退 `p`)+ 本 checkout 的低档(`r` 档时 = 它的 `p` 档)。
- * 缺席形与 {@link resolveProjectIdentity} 同;git 配置在而读不了 ⇒ `unreadable`。
+ * 缺席形 = 找根的缺席词(`bare` / `unreadable`);git 配置在而读不了 ⇒ `unreadable`。
  */
 export declare function projectLayerIdentityOf(taskRoot: string): {
     readonly root: string;

package/dist/project-identity.js

@@ -87,10 +87,6 @@ function canonicalTaskRoot(taskRoot) {
         p = parent;
     }
 }
-export function resolveProjectIdentity(taskRoot) {
-    const located = locateProject(taskRoot);
-    return "root" in located ? { root: located.root } : located;
-}
 function locateProject(taskRoot) {
     const root = canonicalTaskRoot(taskRoot);
     if (root === "unreadable")

package/dist/rules-consent.js

@@ -5,7 +5,7 @@ import { createLogger } from "./observability/logger.js";
 import { ABSOLUTE_HOST_PATH_MAX, hasControlOrBidi } from "@sema-agent/settings-schema";
 import { isDirectWritableRuleBehavior } from "./permission-rule-vocab.js";
 import { hasBidiControls } from "./text-bidi.js";
-import { confirmRuleApproval, RULE_BEHAVIORS, parseRuleText, ruleReachesProgramRun, ruleToolGrammarOf, precheckEditedRuleText, prepareCardApproval, prepareCcImport, redeemRuleBatch, redeemRuleTicket, addPersistedRule, removePersistedRule, isValidDurableScope, effectiveOrThrow, readRowBehavior, readRuleOwner, } from "@sema-agent/core";
+import { confirmRuleApproval, RULE_BEHAVIORS, parseRuleText, ruleReachesProgramRun, precheckEditedRuleText, prepareCardApproval, prepareCcImport, redeemRuleBatch, redeemRuleTicket, addPersistedRule, removePersistedRule, isValidDurableScope, effectiveOrThrow, readRowBehavior, readRuleOwner, } from "@sema-agent/core";
 import { buildRulePayloadHash } from "./plugins/permission-rule-store-sql.js";
 export const RULE_IMPORT_TICKET_TTL_MS = 10 * 60_000;
 export const RULE_IMPORT_RETRY_AFTER_SEC = 2;
@@ -87,7 +87,7 @@ function storeForBucket(provider, ref) {
         }
     }
 }
-function isSupportedRuleMatch(match) {
+function isCommandRuleMatch(match) {
     switch (match) {
         case "exact":
         case "prefix":
@@ -104,6 +104,8 @@ function isSupportedRuleMatch(match) {
         case "host":
         case "subdomain":
             return false;
+        case "tool":
+            return false;
         default: {
             const unknown = match;
             void unknown;
@@ -205,7 +207,7 @@ function screenLocalImportRow(row) {
     const written = parseRuleText(row.rule, row.behavior);
     if ("reject" in written)
         return { reason: "rule_rejected", detail: `${written.reject.code}: ${written.reject.message}` };
-    if (ruleToolGrammarOf(written.rule.tool) !== "command")
+    if (!isCommandRuleMatch(written.rule.match))
         return consistent(written.rule);
     if (written.rule.behavior !== "allow") {
         if (!ruleReachesProgramRun(written.rule, row.command)) {
@@ -354,7 +356,7 @@ export function createRuleConsentLane(stores, opts) {
                 if ("reject" in canonical) {
                     return { ok: false, reason: "edit-rejected", detail: `the canonical spelling the engine minted does not re-parse: ${canonical.reject.message}` };
                 }
-                if (!isSupportedRuleMatch(canonical.rule.match)) {
+                if (!isCommandRuleMatch(canonical.rule.match)) {
                     return { ok: false, reason: "edit-rejected", detail: `the edited rule resolves to an unsupported match form (${String(canonical.rule.match)})` };
                 }
                 ticket = minted.ticket;

package/dist/run-local.js

@@ -45,14 +45,16 @@ import { createMemoryEngineIncidentSink } from "./memory-incident-sink.js";
 import { fileMemoryEngineRoot, memoryEngineBackendFor, memorySpecForRequest } from "./memory-scope.js";
 import { createMemoryProjectLayers } from "./memory-project-layer.js";
 import { assertProjectLayerOwnable } from "./project-identity.js";
+import { declaredCredential } from "./model-route-gap.js";
 import { judgeServedModelRoute } from "./model-route-endpoint.js";
 import { createMemorySyncRunner, createMemorySyncTransport } from "./memory-sync-client.js";
 import { buildPricing, cappedCeiling, createTracer } from "./budget.js";
 import { createSharedRunnerDeps } from "./boot/runner-deps.js";
+import { createPeerDesk } from "./peer-seat.js";
 import { createGovernanceSeams } from "./boot/governance-seams.js";
 import { assertRetentionLaneWirable } from "./boot/retention-lane.js";
 import { createOrgMemoryAdmissionWiring } from "./boot/org-memory.js";
-import { assertDeploymentModsAdmitted, createDeploymentMods } from "./boot/deployment-mods.js";
+import { assembleDeploymentMods } from "./boot/deployment-mods.js";
 import { createKeyResolver } from "./key-resolver.js";
 import { createLogger } from "./observability/logger.js";
 import { fatalExit } from "./boot/fatal-exit.js";
@@ -121,7 +123,7 @@ export function missingGatewayRequirements(config) {
     if (config.gatewayBaseUrl === undefined)
         return missing;
     const perModelEnvs = Object.values(config.modelApiKeyEnv ?? {});
-    const haveGatewayKey = !!config.gatewayApiKey;
+    const haveGatewayKey = declaredCredential(config.gatewayApiKey) !== undefined;
     const catalogModelNames = new Set(Object.values(config.models ?? {}).map((m) => m.name));
     const allModelsHaveOwnKey = catalogModelNames.size > 0 &&
         [...catalogModelNames].every((n) => {
@@ -164,6 +166,7 @@ export const NO_TTY_ASK_CLASS_ROW = {
     shell_floor: { remedy: "shell_gate", autoBudgetReleases: false },
     target_unresolved: { remedy: "terminal_only", autoBudgetReleases: false },
     probe: { remedy: "terminal_only", autoBudgetReleases: false },
+    write_protection_on_disk: { remedy: "terminal_only", autoBudgetReleases: false },
     write_protection: { remedy: "terminal_only", autoBudgetReleases: false },
     tool_marks_mcp: { remedy: "terminal_only", autoBudgetReleases: false },
     tool_marks_a2a: { remedy: "terminal_only", autoBudgetReleases: false },
@@ -363,6 +366,8 @@ export async function runLocal(argv, deps = {}) {
         return 2;
     }
     const configProvider = createConfigProvider(providerInput);
+    const peerDesk = createPeerDesk({ log: logger });
+    const rosterLease = peerDesk.lease("roster");
     let effective;
     let candidatePrompts;
     let applying = false;
@@ -387,9 +392,9 @@ export async function runLocal(argv, deps = {}) {
                 effective = r.effective;
                 candidatePrompts = verdict.prompts;
                 if (effective?.mcp)
-                    config.mcpServers = resolveMcpServers(effective.mcp, logger);
+                    config.mcpServers = resolveMcpServers(effective.mcp, peerDesk, rosterLease, logger);
                 if (effective?.a2a)
-                    config.a2aPeers = resolveA2aPeers(effective.a2a, logger);
+                    config.a2aPeers = resolveA2aPeers(effective.a2a, peerDesk, rosterLease, logger);
                 applyCenterReadFace(config, r.effective, logger, { phase: "boot" });
                 logger.info("config_loaded", { source: configProvider.kind, version: r.effective.version });
             }
@@ -576,9 +581,9 @@ export async function runLocal(argv, deps = {}) {
             { name: "checkpointStore", store: fileBackend.checkpointStore },
             { name: "toolResultStore", store: fileBackend.toolResultStore },
         ],
+        retentionExecutor: null,
     });
-    const deploymentMods = createDeploymentMods({ metrics, brandIdentity: true });
-    await assertDeploymentModsAdmitted(deploymentMods);
+    const { registrations: deploymentMods } = await assembleDeploymentMods({ metrics, brandIdentity: true, declaration: config.modsDeclaration, logger });
     const sharedRunnerDeps = createSharedRunnerDeps({
         metrics,
         config,
@@ -603,6 +608,7 @@ export async function runLocal(argv, deps = {}) {
         orgMemoryAdmission,
         sharedMemoryStores: undefined,
         mcpRevocations: undefined,
+        peerDesk,
     });
     const runnerDeps = {
         ...sharedRunnerDeps,

package/dist/runs.d.ts

@@ -11,6 +11,7 @@ import { type ApprovalFrameFamily, type ToolApprovalCoordinator } from "./tool-a
 import { type FleetRunPublisher } from "./fleet/fleet-bus.js";
 import { type WorkflowCompletionInbox } from "./orchestration/workflow-completion-inbox.js";
 import type { RunAcceptance } from "./run-acceptance.js";
+import type { SessionWorkspaceRecorder } from "./session-workspace.js";
 import type { VerifyRoundsSpec } from "./http/verify-rounds.js";
 import type { UserInputLedger } from "./user-input-ledger.js";
 /**
@@ -374,7 +375,12 @@ userInputLedger?: UserInputLedger,
  * 这次提交的受理座(`src/run-acceptance.ts`):标题器只在引擎受理之后起。普通流形逐帧喂;只回结果的 verify / cascade 形(以及终局写口的
  * 重试腿)终局落行之后收尾一次。缺席 ⇒ 不起标题(起标题此前由路由层在建行时做)。
  */
-acceptance?: RunAcceptance): Promise<void>;
+acceptance?: RunAcceptance, 
+/**
+ * 会话行的位置与项目那一格的记录座(`session-workspace.ts`;唯一写者):普通流形逐帧喂(这条腿自己的 `workspace_changed` 排一次写),
+ * `done` 时等写落定再落终局。只回结果的 verify / cascade 形宿主手里没有流 ⇒ 不记。缺席 ⇒ 不记行(与本参数存在之前逐字相同)。
+ */
+workspaceRecorder?: SessionWorkspaceRecorder): Promise<void>;
 /** How often a running instance refreshes its run's updated_at (liveness, independent of events).
  *  Must stay strictly below `runStaleSec` (asserted at startup AND on every hot config candidate) or the
  *  reaper would race live runs. [ref]:数值的单源是 `config-invariants.ts`(那条不变量的属主),两个消费面

package/dist/runs.js

@@ -84,6 +84,10 @@ const PREPARE_REFUSAL_HTTP_STATUS = {
     "config.legacy_tool_name": 400,
     "config.memory_capture_unsupported": 409,
     "prompt.assembled_role_refused": 400,
+    "config.project_id_invalid": 400,
+    "config.project_identity_mismatch": 409,
+    "config.memory_project_marker": 409,
+    "config.memory_project_marker_nested": 409,
 };
 export function resumeAtHttpStatus(result) {
     const code = failureCodeOf(result.terminal);
@@ -253,7 +257,7 @@ export async function graftParkToolCallId(result, cs) {
     const id = await parkToolCallId(result, cs);
     return id === undefined ? result : { ...result, toolCallId: id };
 }
-export async function runInBackground(runner, spec, runStore, taskId, metrics, principal, verify, cascade, instrumentDegenerate, planCacheProbe, persistThinking = false, inflight, preemptable, steerable, modelUsage, elicitation, elicitOwner, captureTurnAnchor, fleetPublisher, captureUserMessageAnchor, question, workflowCompletionInbox, subagentSteer, completionDiagLog, sendUserFile, promptManifests, approval, parkCheckpointReader, pendingEngineNotices, trustedInternals, userInputLedger, acceptance) {
+export async function runInBackground(runner, spec, runStore, taskId, metrics, principal, verify, cascade, instrumentDegenerate, planCacheProbe, persistThinking = false, inflight, preemptable, steerable, modelUsage, elicitation, elicitOwner, captureTurnAnchor, fleetPublisher, captureUserMessageAnchor, question, workflowCompletionInbox, subagentSteer, completionDiagLog, sendUserFile, promptManifests, approval, parkCheckpointReader, pendingEngineNotices, trustedInternals, userInputLedger, acceptance, workspaceRecorder) {
     const startedAt = Date.now();
     metrics?.addGauge("runs_active", 1);
     fleetPublisher?.onStart();
@@ -453,6 +457,7 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                 fleetPublisher?.onEvent(ev);
                 await userInputLedger?.observeLegEvent(stream, ev);
                 acceptance?.observe(ev);
+                await workspaceRecorder?.observe(ev);
                 await flushPromptManifest();
                 switch (ev.type) {
                     case "text_delta":

package/dist/sandbox-git-plane.d.ts

@@ -52,8 +52,8 @@ export declare function sandboxGitPlanePremisesOf(config: ServiceConfig, reading
 }): SandboxGitPlanePremises;
 /**
  * Wiring point — the effective `sandboxGit` block (the origins this deployment routes through the broker, canonical form, ≤ 16). Its shape
- * and its canonical-form judge belong to the settings-schema contract package (14.7.0); until that release is picked up there is no block to
- * read ⇒ `null` (the plane stays off, `no_origins`). Replaced by the package reader on pickup — no local copy of the shape.
+ * and its canonical-form judge belong to the settings-schema contract package (`SandboxGitConfig`, 14.7.0 — picked up: the block rides the effective
+ * wire verbatim); this reader is not wired to it yet ⇒ `null` (the plane stays off, `no_origins`). To be replaced by the package reader — no local copy of the shape.
  */
 export declare function readSandboxGitConfig(_config: ServiceConfig): {
     readonly origins: readonly string[];

package/dist/server-secret-env.d.ts

@@ -13,7 +13,7 @@
  * 剥掉的键经一个登记过的 `SecretEnvScrubSite` 留痕(现场按**腿**命名);git 腿再叠 git 自己的两件({@link gitSubprocessEnv})。射程 = **每一条**宿主腿:
  * src 里每一只值引 `node:child_process` 的文件都是登记腿、其中每一次起子进程都显式交组合出的 env(普查门在 `test/secret-env-scrub-host-legs.test.ts`)。
  * 腿的继承词是调用点的事实,按「子进程里跑的是谁选的代码」定:模型命令(host shell,交任务自己的词)/ 仓里的钩子与凭据助手(三条 git 腿)/ 执行仓代码的
- * 语言服务器 / 配方脚本 ⇒ 形状剥 `"scrub"`;请求带来的 settings hooks 命令 ⇒ 严格名单(引擎的 `[names]` 臂);部署方装在宿主上的 CLI(`docker` / `adb`,命令本身
+ * 语言服务器 / 配方脚本 ⇒ 形状剥 `"scrub"`;请求带来的 settings hooks 命令 ⇒ 严格名单(十二名基础名单,`[names]` 臂;请求的继承词只给工具 shell、对 hook 不作用)、请求的有效环境层作授予叠在继承结果之上(引擎的 `hostChildEnv`);部署方装在宿主上的 CLI(`docker` / `adb`,命令本身
  * 在容器 / 设备里跑、那边的 env 由 `-e` 显式给)⇒ `"all"` —— 只扣本服务自有凭据,CLI 与它的凭据助手 / 插件要读的生态变量照交(形状剥会剥
  * `ADB_VENDOR_KEYS` / `AWS_SECRET_ACCESS_KEY` 一类,实测)。三个继承词只在引擎一处判:
  *  · `"all"` = 整份环境 **减** 本进程声明的自有凭据名;`"scrub"`(缺省)= 形状剥 ∪ 该名单;`[names]` = 严格白名单,点到名单中的名 ⇒ 引擎响亮拒
@@ -94,18 +94,21 @@ export declare function ownCredentialsWithheld(): boolean;
 export declare function ownCredentialValuesWithheld(): boolean;
 /** 测试缝:撤回声明(引擎侧重声明为空表)、忘掉两份声明镜像、点名记账与活配置;生产代码从不调它。 */
 export declare function __resetServerWithheldEnvForTest(): void;
-/** 一条宿主腿要什么:现场(留痕)、继承策略(缺省 `"scrub"`;按头注「腿的继承词」一条由调用点定)、部署方点名放回的键。 */
+/** 一条宿主腿要什么:现场(留痕)、继承策略(缺省 `"scrub"`;按头注「腿的继承词」一条由调用点定)、部署方点名放回的键、调用方显式交的授予(按序叠在继承之上,后者赢)。 */
 export interface HostSubprocessEnvRequest {
     readonly site: SecretEnvScrubSite;
     readonly policy?: InheritEnvPolicy | undefined;
     readonly allow: readonly string[];
+    /** 调用方显式交给子进程的变量(今天只有 settings hooks:有效环境层 = 请求 `settings.env` + hook 自己的变量)。引擎判形:名字空 / 带 `=` / NUL / 孤代理项、
+     *  值不是串或带 NUL / 孤代理项 ⇒ 组合**抛**,拒句点名授予与变量(不带值、不回显坏名);调用点按「起不来」处置。 */
+    readonly grants?: readonly Readonly<Record<string, string>>[] | undefined;
 }
 /**
  * 🔴 **宿主子进程 env 的唯一组合**:{@link composeHostSubprocessEnv} + 留痕。**没有按原样交给子进程**的名字(剥掉的)经 `site` 留痕;点名放回的键取回源值,
  * 不是剥除,不计数、不披露。源 env 恒为本进程 env(引擎只读 `process.env`,本仓没有第二个源)。
  *
  * 九条宿主腿都只经它(直接或经 {@link gitSubprocessEnv}):host shell(三个继承词原样交给 `policy`)、project-memory / center-plugins / leader 三条 git 腿、
- * 本地语言服务器、bake-runner 的每一只子进程组、local-docker 与 adb 两条 CLI 腿(`"all"`)、settings hooks 的命令腿(严格名单)。`allow` 只在**有部署级出路**的现场非空(今天 = `LSP_ENV_ALLOW` / `BAKE_ENV_ALLOW`,
+ * 本地语言服务器、bake-runner 的每一只子进程组、local-docker 与 adb 两条 CLI 腿(`"all"`)、settings hooks 的命令腿(十二名严格名单 + 有效环境层作授予)。`allow` 只在**有部署级出路**的现场非空(今天 = `LSP_ENV_ALLOW` / `BAKE_ENV_ALLOW`,
  * 它们的现场在 `SECRET_ENV_SCRUB_SITES` 里登记了 `remedy`,披露行因此是 warn + 放行名单 + 出路句);其余现场传 `[]`。
  * 返回 `NodeJS.ProcessEnv` 形(值可能是 `undefined` 的键本来就不会进子进程);调用方显式要交的键(`LC_ALL`、`cfg.env` …)叠在它之上。
  * 调用时机 = 每次要交 env 时现算一次(`process.env` 在本仓是 boot 期输入,各次同值;计数因此是「每组合一次」)。

package/dist/server-secret-env.js

@@ -1,4 +1,4 @@
-import { declareWithheldEnv, inheritedHostEnv } from "@sema-agent/core";
+import { declareWithheldEnv, hostChildEnv, inheritedHostEnv } from "@sema-agent/core";
 import { CONFIG_CATALOG } from "./config-catalog.js";
 import { ENV_NAME_ALLOWLIST_KNOB_NAMES } from "./env-name-allowlist-knobs.js";
 import { recordSecretEnvScrub } from "./observability/secret-env-scrub.js";
@@ -84,7 +84,9 @@ export function hostSubprocessEnv(o) {
 }
 export function composeHostSubprocessEnv(o, findings = []) {
     const putBack = o.allow.length > 0 ? inheritedHostEnv([...o.allow], findings) : {};
-    return { ...inheritedHostEnv(o.policy ?? "scrub", findings), ...putBack };
+    const child = hostChildEnv(o.policy ?? "scrub", putBack, ...(o.grants ?? []));
+    findings.push(...child.withheld);
+    return child.env;
 }
 export function withheldFromHostSubprocess(o, regranted) {
     const findings = [];

package/dist/session-incarnation.d.ts

@@ -117,14 +117,13 @@ export declare function sessionFaceOfHead(sessionId: string, head: SessionHead |
  */
 export declare function headReadOf(store: object | undefined): HeadRead | undefined;
 /**
- * session-sync **整段换装**(replace)时化身的去留 —— 三只店共用的一句判据:换装删掉再插回的是**同一位住客**的那一行
- * (删除带属主门),所以行在、属主相同、那一格里有一只令牌(唯一解码 {@link incarnationFromCell} 的 `absent` 读法)⇒ 沿用;
- * 行不在(这是一次新建)或还是空的存量形 ⇒ 铸一只新的。
+ * session-sync **换装**(整段换装 / 暂存提交 / local 落在既有行上的导入)时化身的去留 —— 三只店共用的一句判据:换装只换内容,换的是**同一行**
+ * ⇒ 行在且那一格里有一只令牌(唯一解码 {@link incarnationFromCell} 的 `absent` 读法)⇒ 沿用(属主重戳与否不改这一判:同一行 = 同一位住客);
+ * 行不在(这是一次新建)或还是空的存量形 ⇒ 铸一只新的。属主不在这里判:每只店在自己的属主门上判过被换的那一行,读不中的换装一个字节不写。
  */
 export declare function carriedIncarnation(sessionId: string, prior: {
-    owner?: unknown;
     incarnation?: unknown;
-} | undefined, owner: string | null): string;
+} | undefined): string;
 /**
  * `session_meta.incarnation` 的列定义 —— 两方言各一句,**唯一属主**:中央 DDL(`tidb-pool.ts` / `pg-session-storage.ts` 的
  * `CREATE TABLE session_meta`)内插这同一串;存量库缺这一列时,起服列册探针(`schema-consistency.ts`)拒启,拒句里的 `ALTER TABLE … ADD COLUMN …`

package/dist/session-incarnation.js

@@ -67,8 +67,8 @@ export function headReadOf(store) {
     const read = store?.headOf;
     return typeof read === "function" ? read.bind(store) : undefined;
 }
-export function carriedIncarnation(sessionId, prior, owner) {
-    const held = prior !== undefined && (prior.owner ?? null) === owner ? incarnationFromCell(sessionId, prior.incarnation, "absent") : undefined;
+export function carriedIncarnation(sessionId, prior) {
+    const held = prior === undefined ? undefined : incarnationFromCell(sessionId, prior.incarnation, "absent");
     return held ?? mintSessionIncarnation();
 }
 export const SESSION_META_INCARNATION_COLUMN = {

package/dist/session-workspace.d.ts

@@ -0,0 +1,130 @@
+/**
+ * **会话的位置与项目** —— 一个事实、一个写者、一种读法(引擎 7.58.0:`workspace_changed` 是腿的整份快照;
+ * 会话行 = 该会话上最后一帧)。
+ *
+ * ## 律(三句)
+ *  · **判官只有引擎一只**:每条腿起点一帧 `workspace_changed`(`cwd` / `root` / `entered?` / `project?` / `remote`),之后每变一帧;
+ *    这条腿属于哪个项目由引擎对检出的 `.sema/project` 记号判一次(带了 `TaskSpec.projectId` 就必须等于记号,
+ *    否则整腿拒 `config.project_identity_mismatch`;没有记号时声明就是身份)。本仓**不判**项目、不读记号。
+ *  · **会话行只存一格**:`workspace` = 该会话上一条腿**自己的**最后一帧(SQL `session_meta.workspace`;local 店
+ *    `session-workspaces.json` 那一格)。成员由 {@link SESSION_WORKSPACE_DISPOSITIONS} 一张表定(引擎给帧加成员 ⇒ 表 tsc 红,
+ *    门在 `trace/core-keyset-guard.ts` ⑰ 读同一张表)。**唯一写者** = 腿的记录座 {@link createSessionWorkspaceRecorder}
+ *    (持流的四条腿逐帧喂同一只;委派子代转上来的帧 —— 带 `parentToolCallId` / `sourceTaskId` / `bgAgentId` —— 不是这条腿的位置,不认)。
+ *    每一笔写**在腿的流循环里等完**(不排队、没有在飞的写:腿从任何出口离开时都没有它的写还悬着 ⇒ 写恒落在这条腿的 run 认领之内,
+ *    同一会话的下一条腿不会被一笔晚到的写盖掉),并且**只写受理时见证到的那一位住客**({@link stampLegSessionWitness}:resolveSpec
+ *    受理时读会话行的化身那一读,同一只值也是委派树根的见证)—— 会话被删掉又以同一 id 重建之后,上一位住客的腿写不进新住客的行。
+ *  · **每条腿声明一个值**:`TaskSpec.projectId` = 这次提交自己带的 `projectId`(新提交的请求体;续跑腿重放的是持久化的同一个体)
+ *    ?? 会话行上最后一帧的 `project.id` —— **只当它是调用方声明过的**(`source: "declared"`:没有记号的检出里声明就是身份,行存它就是为了接着声明);
+ *    `source: "marker"` 是引擎对**那一次**检出的记号判决,不续声明(引擎每条腿对自己的检出再判 —— 记号改写 / 换检出之后续跑照跑);
+ *    都没有 ⇒ 不带(引擎在有记号的检出里自判)。唯一铸点 {@link legProjectIdOf},唯一调用点 `boot/resolve-spec.ts`(新提交与续跑同经那一只装配)。
+ *
+ * ## 什么因此变少
+ * 修前请求键 `projectId` 被提交口受理、却从不交给引擎(keyset 守卫记该引擎座「未接线」,与受理表相反 —— 编译门 ② 红着);
+ * 会话在没有记号的检出里续跑时,项目随每一次不带 `projectId` 的提交丢掉。现在:一个值进引擎、一格存引擎的答案、下一条腿读那一格。
+ *
+ * ## 不在这里的(如实)
+ *  · **记忆项目层**(单用户 `userrepo:` 键,`project-identity.ts` 的 git 检出身份)不是这个事实:它在装配期(任何帧之前)交给
+ *    `TaskSpec.memory.projectKey`,按 git 仓库(origin 远端 / 本机路径)键控,与 `.sema/project` 记号无关;引擎 7.58.0 自己也写明
+ *    「只声明的身份不改记忆的键」。两者是否该合成一个身份,是另一张设计票。
+ *  · 多租户记忆分区(`proj:<租户>/<projectId>`)与登记簿种子读的是**这次提交**的 `projectId`(按提交挑盘,修前即如此),不读行。
+ *  · 行上的 `root` / `cwd` / `entered` / `remote` 今天只存不读(会话面读它们归 wire 半场那一车);fork 出的新会话从「没有记录」起。
+ *  · **只回结果的腿(verify / cascade,含续跑的 verify 臂)不记行**:引擎在组合入口里自己排空内层腿的流,宿主手里没有流,而引擎给组合入口开的
+ *    帧座(`onStatusEvent` / `onWiringManifest`)没有这一帧 ⇒ 这条腿的位置与项目到不了行,行停在更早一条腿的那一帧(没有记号的检出里,
+ *    下一条不带 `projectId` 的提交续声明的是那一帧声明过的项目)。本仓不替引擎铸「这条腿站在哪里」;要引擎为组合入口开这一帧的座。
+ *  · **行读在 run 认领之前**(resolveSpec 的每一读都是):同一会话两次提交交叠、后一次的装配读行之后前一次才落定并放认领 ⇒ 后一次读到的是更早
+ *    一条腿的项目(有记号的检出里多一次 409,没有记号的检出里续声明旧项目)。修法要把声明的装配挪到认领之后,不在本模块补第二个写者。
+ */
+import type { TaskEvent, TaskSpec } from "@sema-agent/core";
+import type { DelegationRootWitness } from "./delegated-session-owner.js";
+/**
+ * `workspace_changed` 帧在会话行上的样子(**唯一**一张表;表序 = 存储形的键序)。`forward` = 原值存进行;`strip` = 不进行。
+ * 腿身份四键(`eventId` / `parentToolCallId` / `sourceTaskId` / `bgAgentId`)是这一帧在流上的身份,不是位置;`type` 是臂名。
+ */
+export declare const SESSION_WORKSPACE_DISPOSITIONS: {
+    readonly type: "strip";
+    readonly cwd: "forward";
+    readonly root: "forward";
+    readonly entered: {
+        readonly nested: {
+            readonly dir: "forward";
+            readonly byPath: "forward";
+        };
+    };
+    readonly project: {
+        readonly nested: {
+            readonly id: "forward";
+            readonly source: "forward";
+        };
+    };
+    readonly remote: "forward";
+    readonly eventId: "strip";
+    readonly parentToolCallId: "strip";
+    readonly sourceTaskId: "strip";
+    readonly bgAgentId: "strip";
+};
+type WorkspaceFrame = Extract<TaskEvent, {
+    type: "workspace_changed";
+}>;
+/** 表里存进行的键(`strip` 之外的)—— 存储形由表派生,不另写一份成员清单。 */
+type KeptKeys = {
+    [K in keyof typeof SESSION_WORKSPACE_DISPOSITIONS]: (typeof SESSION_WORKSPACE_DISPOSITIONS)[K] extends "strip" ? never : K;
+}[keyof typeof SESSION_WORKSPACE_DISPOSITIONS];
+/** 会话行上那一格的值:最后一帧里本仓存下的成员(型从引擎的帧臂派生)。 */
+export type SessionWorkspace = Pick<WorkspaceFrame, KeptKeys>;
+/** 会话店的这一面(两只方法都在才算 —— 只有一半的店让读写不同源)。 */
+export interface SessionWorkspaceStore {
+    /** 这只会话上最后一帧;没有记录 / 没有这一行 ⇒ `undefined`。格读不出 ⇒ 读作没有记录并计一次(`decodeSessionWorkspaceCell`)。 */
+    readSessionWorkspace(sessionId: string): Promise<SessionWorkspace | undefined>;
+    /**
+     * 整格覆写(最后一帧胜),**只写住客是 `incarnation` 那一位的行**:行不在、或此刻坐的是另一位住客 ⇒ 不写、不抛(那一行不是这条腿的)。
+     * 写**没有提交**必须抛。SQL 两孪生走店的一般查询面(与腿循环里的账本追加同一形,不设每查询的客户端超时 —— 客户端放弃等待而服务端照跑完的写,
+     * 正是能在这条腿离开之后落地的那一形);卡住的上界归服务端(锁等待超时 / 部署的 `DB_QUERY_TIMEOUT_MS`)。
+     */
+    recordSessionWorkspace(sessionId: string, incarnation: string, workspace: SessionWorkspace): Promise<void>;
+}
+/** 店有没有这一面 —— 结构判(包装店 `CachingSessionStore` 逐方法转发,判的是能力不是名字)。没有 ⇒ 不记、不读(core 的内存 dev 店)。 */
+export declare function sessionWorkspaceStoreOf(store: unknown): SessionWorkspaceStore | undefined;
+/**
+ * 这条腿的会话**在受理时**是哪一位住客(会话 id + 化身令牌)的 spec 字段键 —— 与 run 名册 / 执行车道字段同一形:symbol 键随 spread / rest 解构走
+ * (续跑腿的 `taskConfig` 是 rest 解构出来的),对引擎的键面不可见(JSON / 结构化克隆跳过 symbol 键)。铸点唯一 = resolveSpec 出口
+ * ({@link stampLegSessionWitness}),值 = 受理时读会话行的那**一**读(同一只值也交给场景层作委派树根的见证);读点唯一 = {@link legSessionWitnessOf}。
+ */
+export declare const LEG_SESSION_WITNESS_FIELD: unique symbol;
+/** 铸见证(**单一属主**:只许 resolveSpec 的出口调用)。`writable:false` + `configurable:false`:同一只 spec 被第二次铸 ⇒ 当场 TypeError。缺席 ⇒ 不铸。 */
+export declare function stampLegSessionWitness<T extends TaskSpec>(spec: T, witness: DelegationRootWitness | undefined): T;
+/** 读见证。`undefined` = 这只 spec 不是本仓装配出口产的,或这条腿没有会话 ⇒ 记录座不写(没有住客可认)。入参收 `object`:续跑腿手里是 rest 解构出来的 taskConfig。 */
+export declare function legSessionWitnessOf(spec: object): DelegationRootWitness | undefined;
+/**
+ * 一帧 → 会话行上那一格的值。只认这条腿**自己的**帧(腿身份三键任一在场 = 委派子代转上来的,不是这条腿站在哪里);
+ * 按表投影后过存储形的同一只读者(写得进的就是读得出的)。读不出(引擎不会铸出这种帧)⇒ 不记、计一次。
+ */
+export declare function sessionWorkspaceOfFrame(ev: TaskEvent): SessionWorkspace | undefined;
+/** 腿的记录座。 */
+export interface SessionWorkspaceRecorder {
+    /**
+     * 持流的腿**逐帧**调用并等它(在本腿的取消成因闩之后)。这条腿自己的 `workspace_changed` ⇒ 这一笔写写完(或失败计一次)才兑现 ——
+     * 帧按到达序一笔一笔写,最后一帧胜;腿从任何出口(`done`、断连 `break`、抛)离开时没有写还悬着。其余帧当场兑现。**从不抛、从不拒**。
+     */
+    observe(ev: TaskEvent): Promise<void>;
+}
+/**
+ * 记录座的**唯一**铸点(四条持流腿各在开流时铸一只:后台腿 `runs.ts`、活流腿与同步腿 `http/routes/tasks.ts`、续跑腿 `http/resume-legs.ts`),
+ * `witness` = 这条腿 spec 上的受理见证({@link legSessionWitnessOf})。店没有这一面、或见证缺席 / 受理时这只会话还没有住客令牌 ⇒
+ * 一只什么都不做的座(诚实缺席:认不出住客就不写 —— 写错住客比少记一次坏)。
+ *
+ * 失败方向(F 类):写失败(库抖 / 盘满 / 锁等待超时)⇒ 行停在上一帧,计一次;下一帧照写。放行的最坏后果 = 下一条不带 `projectId` 的提交读到旧的
+ * (或没有)项目 —— 有记号的检出里引擎照判记号(声明不等就响亮拒),没有记号的检出里这只会话少一次续声明。不放行的代价是把一条在跑的腿
+ * 为一次记录摔掉。等一笔写的代价 = 这条腿的流晚一次主键 UPDATE 的时延(引擎不等宿主消费,只是帧晚到;一条腿的帧只有起点一帧加每次换位一帧)。
+ * 库卡住(池取不到连接)时这条腿交给调用方的结果跟着等:后台腿与续跑腿的循环本来每一帧就等店写(账本追加);同步腿与不落账的活流腿此前循环里没有店写,
+ * 现在多等这一笔 —— 但同一只池上引擎自己的会话条目写(每一轮 `appendEntry`,`plugins/store-backend.ts` 的 `session()` 与其余店共用一池)本来就在
+ * 这条腿的关键路径上,池饿死时这条腿本来就停;上界归部署(`DB_QUERY_TIMEOUT_MS`、MySQL 池的排队上界)。local 后端的写不经池。
+ */
+export declare function createSessionWorkspaceRecorder(store: SessionWorkspaceStore | undefined, witness: DelegationRootWitness | undefined): SessionWorkspaceRecorder;
+/**
+ * **这条腿交给引擎的 `TaskSpec.projectId`**(唯一铸点;见文件头第三句)。`submitted` = 这次提交自己带的、已过形状门且折成小写的值
+ * (新提交:鉴权口的 `resolvedProjectId`;续跑:持久化体的同一个键)。它在场就不读行。行读失败(库抖)原样上抛 —— 读不到「这只会话的项目」
+ * 不能悄悄折成「没有项目」(那会把一只登记在项目下的会话在没有记号的检出里改成无项目)。
+ */
+export declare function legProjectIdOf(submitted: string | undefined, store: SessionWorkspaceStore | undefined, sessionId: string | undefined): Promise<string | undefined>;
+export {};
+//# sourceMappingURL=session-workspace.d.ts.map

package/dist/session-workspace.js

@@ -0,0 +1,83 @@
+import { recordFailOpen } from "./observability/fail-open.js";
+import { readSessionWorkspaceCell, SESSION_WORKSPACE_DEGRADED } from "./plugins/session-workspace-cell.js";
+import { projectByTable } from "./trace/projection-table.js";
+export const SESSION_WORKSPACE_DISPOSITIONS = {
+    type: "strip",
+    cwd: "forward",
+    root: "forward",
+    entered: { nested: { dir: "forward", byPath: "forward" } },
+    project: { nested: { id: "forward", source: "forward" } },
+    remote: "forward",
+    eventId: "strip",
+    parentToolCallId: "strip",
+    sourceTaskId: "strip",
+    bgAgentId: "strip",
+};
+export function sessionWorkspaceStoreOf(store) {
+    const s = store;
+    if (typeof s?.readSessionWorkspace !== "function" || typeof s.recordSessionWorkspace !== "function")
+        return undefined;
+    return { readSessionWorkspace: s.readSessionWorkspace.bind(s), recordSessionWorkspace: s.recordSessionWorkspace.bind(s) };
+}
+export const LEG_SESSION_WITNESS_FIELD = Symbol("sema-server.legSessionWitness");
+export function stampLegSessionWitness(spec, witness) {
+    if (witness !== undefined)
+        Object.defineProperty(spec, LEG_SESSION_WITNESS_FIELD, { value: Object.freeze({ ...witness }), enumerable: true, writable: false, configurable: false });
+    return spec;
+}
+export function legSessionWitnessOf(spec) {
+    return spec[LEG_SESSION_WITNESS_FIELD];
+}
+export function sessionWorkspaceOfFrame(ev) {
+    if (ev.type !== "workspace_changed")
+        return undefined;
+    if (ev.parentToolCallId !== undefined || ev.sourceTaskId !== undefined || ev.bgAgentId !== undefined)
+        return undefined;
+    const shape = readSessionWorkspaceCell(projectByTable("session_workspace", SESSION_WORKSPACE_DISPOSITIONS, ev, ev));
+    if (shape.problem !== undefined) {
+        recordFailOpen(SESSION_WORKSPACE_DEGRADED, `op=frame problem=${shape.problem.slice(0, 200)}`);
+        return undefined;
+    }
+    return shape.value;
+}
+const SETTLED = Promise.resolve();
+const NO_RECORD = { observe: () => SETTLED };
+export function createSessionWorkspaceRecorder(store, witness) {
+    if (store === undefined || witness === undefined || witness.incarnation === null)
+        return NO_RECORD;
+    const { sessionId, incarnation } = witness;
+    return {
+        async observe(ev) {
+            const snapshot = sessionWorkspaceOfFrame(ev);
+            if (snapshot === undefined)
+                return;
+            try {
+                await store.recordSessionWorkspace(sessionId, incarnation, snapshot);
+            }
+            catch (e) {
+                recordFailOpen(SESSION_WORKSPACE_DEGRADED, `op=write session=${sessionId} ${(e instanceof Error ? e.message : String(e)).slice(0, 200)}`);
+            }
+        },
+    };
+}
+export async function legProjectIdOf(submitted, store, sessionId) {
+    if (submitted !== undefined)
+        return submitted;
+    if (store === undefined || sessionId === undefined)
+        return undefined;
+    const project = (await store.readSessionWorkspace(sessionId))?.project;
+    return project === undefined ? undefined : replayedProjectIdOf(project);
+}
+function replayedProjectIdOf(project) {
+    switch (project.source) {
+        case "declared":
+            return project.id;
+        case "marker":
+            return undefined;
+        default: {
+            const unknownSource = project.source;
+            throw new Error(`session workspace: unknown project source word ${JSON.stringify(unknownSource)} (the row reader admits only marker / declared)`);
+        }
+    }
+}
+//# sourceMappingURL=session-workspace.js.map

package/dist/spec-fields.d.ts

@@ -108,7 +108,7 @@ export interface TaskAgentsRefusal {
  *  定义被悄悄削(一个丢掉的 isolation 就是放宽),比 400 更危险,故整条拒。`allowTools` / `denyTools` 本门只判形与条数(`toolList`),
  *  **名字归引擎一只判**(core 7.49.0 [ref] / [ref] 第二步起与根 run 的 `allowTools` / `excludeTools` 是同一只选择器,开跑前,三来源同判):core 7.51.0 [ref] 起
  *  没有任何工具答应的名字(无人挂的名、大小写孪生 / 退役名 `bash` / `BASH`)**引擎不拒 run** —— 条目原样保留、经 onError(config)告知一次(带该写的拼法);
- *  其中**写错现名的**(`denyTools:["BASH"]` 想禁的照用 = 静默放行;`allowTools:["BASH"]` 想放的什么也没放 = 静默收窄)由 `resolveSpec` 前置拒:**限制侧**(`denyTools`)四类全拒(近似名 · 退役名 · 文法读不出 · `*`),
+ *  其中**写错现名的**(`denyTools:["BASH"]` 想禁的照用 = 静默放行;`allowTools:["BASH"]` 想放的什么也没放 = 静默收窄)由 `resolveSpec` 前置拒:**限制侧**(`denyTools`)三类全拒(近似名 · 退役名 · 文法读不出);名内的 `*` 自 7.137.0 起是整名 glob、受理(孤 `*` = 每一只工具),`Tool(content)` 引擎读成整只工具、同样受理,
  *  **放行侧**(`allowTools`)只拒近似名 —— 放行侧的内容形 / 没有后继的退役名 / 文法读不出照 7.130.0 受理、交引擎既有通告(有后继的退役名〔`bash` · `Task`〕与文法读不出的放行条目引擎在子代 prepare 整 run 拒 `config.agent.unknown_tool`,根 `allowTools` 拒 `config.tool_face_control`,同步腿两码同为 400〔`runs.ts` `PREPARE_REFUSAL_HTTP_STATUS`〕;`rule-entry-list.ts` `inertToolListEntryOf`:近似名提交 400 `config.agent.unknown_tool` 点名现名、续跑按方向分流;
  *  判官仍是引擎的条目读法,不是第二个判官);
  *  **真未知名**(没有近似也没有退役对应:懒挂载的合法形)照旧只告运维、不拒。

package/dist/standing-answer-grant.d.ts

@@ -1,12 +1,8 @@
-/** 卡载体:引擎铸的问 / 停驻行 / 它们的投影行(活的 `AskRequest`、停驻行的 `tool_approval` 臂、运维队列行都结构上满足)。 */
+/** 载体:引擎给一次调用盖过绑定词的任何形(活的 `AskRequest`、停驻行的 `tool_approval` 臂、运维队列行、策略层的 `ToolCallRequest` 都结构上满足)。 */
 export interface StandingAnswerCard {
     readonly boundGrantDigest?: unknown;
     readonly boundGrantAbsence?: unknown;
 }
-/** 调用载体:策略层的 `ToolCallRequest`、豁免店的行(只有工具名)。 */
-export interface StandingAnswerCall {
-    readonly toolName?: unknown;
-}
 /** 一问的授予绑定(闭集):`none` = 应答只覆盖这一次调用;`bound` = 授予、绑定可读;`unreadable` = 授予或说不清、绑定读不出。 */
 export type GrantBinding = {
     readonly kind: "none";
@@ -16,13 +12,6 @@ export type GrantBinding = {
 } | {
     readonly kind: "unreadable";
 };
-/** 卡上的授予绑定 —— 只读引擎的词(读法见文件头注):摘要是串 ⇒ bound;摘要不在且词是 `not_bindable` ⇒ none;其余 ⇒ unreadable。 */
+/** 载体上的授予绑定 —— 只读引擎的词(读法见文件头注):摘要是串 ⇒ bound;摘要不在且词是 `not_bindable` ⇒ none;其余 ⇒ unreadable。 */
 export declare function grantBindingOf(card: StandingAnswerCard): GrantBinding;
-/** 调用上的授予绑定 —— 调用上没有引擎的词,读引擎绑定工厂的那一条规则(见文件头注;🚧 引擎在调用上盖词之后退役)。 */
-export declare function callGrantBindingOf(call: StandingAnswerCall): GrantBinding;
-/**
- * 一问的授予绑定的**唯一折点**:读哪个载体由**问的属主**定 —— 名单自己的问(`deploymentListQuestion`,即 `standingAnswerHome` 的 `server_store` 家)读调用口,
- * 引擎铸的问读卡口(载体与理由见文件头注)。所有把「一张卡」折成 {@link StandingAnswerFacts} 的读者(活的问、待决条目、停驻行、运维队列行)经它取绑定,不各自选口。
- */
-export declare function questionGrantBindingOf(carrier: StandingAnswerCard & StandingAnswerCall, deploymentListQuestion: boolean): GrantBinding;
 //# sourceMappingURL=standing-answer-grant.d.ts.map

package/dist/standing-answer-grant.js

@@ -1,4 +1,3 @@
-import { SKILL_TOOL_NAME } from "@sema-agent/core";
 const NOT_BINDABLE = "not_bindable";
 export function grantBindingOf(card) {
     const digest = card.boundGrantDigest;
@@ -6,10 +5,4 @@ export function grantBindingOf(card) {
         return { kind: "bound", digest };
     return digest === undefined && card.boundGrantAbsence === NOT_BINDABLE ? { kind: "none" } : { kind: "unreadable" };
 }
-export function callGrantBindingOf(call) {
-    return call.toolName === SKILL_TOOL_NAME ? { kind: "unreadable" } : { kind: "none" };
-}
-export function questionGrantBindingOf(carrier, deploymentListQuestion) {
-    return deploymentListQuestion ? callGrantBindingOf(carrier) : grantBindingOf(carrier);
-}
 //# sourceMappingURL=standing-answer-grant.js.map