@sema-agent/server 7.149.0 → 7.150.0

package/dist/plugins/stop-then-start-sentence.d.ts

@@ -2,15 +2,54 @@
  * 「停-迁-起」那一段的**唯一属主**。
  *
  * 一次性迁移里有几条(登记表 `stopThenStart` 一格点名的)改的是更早版本的副本还会继续写的形:改完之后它再写一笔,这一笔读不出 / 丢掉。它们没有运行期开关,
- * 起服时由守卫判 —— 判活窗内(`REAP_RUN_STALE_SEC`,收割器判 run 持有者还活着的同一个窗)库里还有 `running` run 在心跳 ⇒ 拒启、一字节不写。
+ * 起服时由守卫判 —— 库上有「不知道这条迁移的副本还在服务」的证据 ⇒ 拒启、一字节不写。证据只有一种读法(`one-time-migrations.ts` 的 `readOlderReplicaEvidence`):
+ * 判活窗内(`REAP_RUN_STALE_SEC`,收割器判 run 持有者还活着的同一个窗)心跳过的 `running` run,持有者没有登记为知道这条迁移(`replica-registration.ts`)。
  * 四只守卫(M40 · M41 · M42 · M51)的拒句和起服列册对账的升级清单**说同一件事**:先停光更早版本的副本、等满判活窗、再起本版。
- * 这件事的句子只在这里写一遍;各守卫只讲「为什么这一条要停」,不各抄一份动作段。
+ * 这件事的句子只在这里写一遍:证据一段({@link olderReplicaEvidenceSentence})与动作一段({@link stopThenStartAction});各守卫只讲「为什么这一条要停」。
+ * 起服准入(`serving-requirement.ts`:库上记着本构建没有的能力 ⇒ 拒启)的拒句同属这一族,也在这里({@link servingRequirementUnmetSentence})。
  *
- * 叶子模块:零 import(守卫所在的一次性迁移文件、M42 的拒句文件与列册对账都静态 import 它,不成环)。
+ * 叶子模块:零 import(守卫所在的一次性迁移文件、M42 的拒句文件、起服准入与列册对账都静态 import 它,不成环)。
  */
+/** 证据里一只登记过、却没有这条迁移能力的持有者(归因用:点名它是谁)。 */
+export interface OlderReplicaHolder {
+    readonly instanceId: string;
+    readonly releaseLine: string;
+    readonly hostName: string;
+    readonly pid: number;
+    /** 它持有的、判活窗内心跳过的 `running` run 数。 */
+    readonly runs: number;
+}
+/**
+ * 停-迁-起守卫的证据(纯数据):判活窗内心跳过、持有者没有登记为知道 {@link migration} 的 `running` run。
+ * 登记为知道它的持有者的 run 不在这里(它们不是旧形写者);登记只作归因,不判活。
+ */
+export interface OlderReplicaEvidence {
+    readonly migration: string;
+    /** 算进证据的 run 总数(= {@link unregisteredRuns} + 各 {@link registeredWithout} 的 `runs`)。 */
+    readonly liveRuns: number;
+    readonly windowSec: number;
+    /** 全停之后可以再起的最早时刻(ISO;= 最新心跳 + 判活窗;读不出最新心跳 ⇒ 现在 + 窗,上界)。 */
+    readonly restartAfter: string;
+    /** 同一时刻的人读形(带「离现在还有几秒」)。 */
+    readonly after: string;
+    /** 持有者没有登记行(或没有持有者)的 run 数。 */
+    readonly unregisteredRuns: number;
+    /** 登记了而能力名单里没有这条迁移的持有者,逐只点名。 */
+    readonly registeredWithout: readonly OlderReplicaHolder[];
+}
+/** 证据一段(各守卫拒句与 M43 的读数共用;句子不含时刻 —— 时刻在动作段)。 */
+export declare function olderReplicaEvidenceSentence(e: OlderReplicaEvidence): string;
 /**
  * 动作段:停光 → 等窗 → 再起。`after` = 全停之后可以再起的最早时刻(守卫读到的最新心跳 + 判活窗,人读形);
  * 缺席 ⇒ 读不到具体心跳(列册对账的清单:此刻没有守卫在判),只说「等满判活窗」。
  */
 export declare function stopThenStartAction(after?: string): string;
+/** 起服准入里一行本构建没有的要求(`state` = 判读的态,词表外的词读作 `in_force`;`word` = 库里存的原词)。 */
+export interface UnmetServingRequirement {
+    readonly migration: string;
+    readonly state: "pending" | "in_force";
+    readonly word: string;
+}
+/** 起服准入的拒句(`reason` 闭集两词;码由调用方交,本模块零 import)。 */
+export declare function servingRequirementUnmetSentence(code: string, reason: "capability_missing" | "table_absent", unmet: readonly UnmetServingRequirement[], absentTables: readonly string[], releaseLine: string): string;
 //# sourceMappingURL=stop-then-start-sentence.d.ts.map

package/dist/plugins/stop-then-start-sentence.js

@@ -1,7 +1,51 @@
+export function olderReplicaEvidenceSentence(e) {
+    const parts = [];
+    if (e.unregisteredRuns > 0)
+        parts.push(`${e.unregisteredRuns} by replicas with no registration on this database (a release that predates replica registration, or a process that skipped the start sequence)`);
+    for (const h of e.registeredWithout)
+        parts.push(`${h.runs} by instance ${h.instanceId} (release ${h.releaseLine}, host ${h.hostName}, pid ${h.pid}), registered without it`);
+    return (`${e.liveRuns} running run(s) on this database heartbeated within the last ${e.windowSec}s (REAP_RUN_STALE_SEC), held by replicas not registered as knowing one-time migration ${e.migration}` +
+        ` (${parts.join("; ")})`);
+}
 export function stopThenStartAction(after) {
     return ("Stop every replica of the earlier version, then start this version (stop, migrate, start — this release cannot be rolled across replicas of both versions). " +
         (after === undefined
             ? "Wait out the heartbeat window (REAP_RUN_STALE_SEC) after the last replica stops, then start this version."
             : `If every replica is already stopped, those are the runs they left behind: start this version again after ${after}`));
 }
+function requirementClause(r) {
+    switch (r.state) {
+        case "pending":
+            return `${r.migration} (pending: a newer build recorded it and has not changed any data for it yet)`;
+        case "in_force":
+            return r.word === "in_force"
+                ? `${r.migration} (in force: data has been changed for it)`
+                : `${r.migration} (state "${r.word}", which this build does not know — read as in force)`;
+        default: {
+            const unhandled = r.state;
+            throw new Error(`stop-then-start-sentence: unknown requirement state ${String(unhandled)}`);
+        }
+    }
+}
+export function servingRequirementUnmetSentence(code, reason, unmet, absentTables, releaseLine) {
+    switch (reason) {
+        case "capability_missing": {
+            const inForce = unmet.filter((r) => r.state === "in_force").map((r) => r.migration);
+            return (`${code} (reason: capability_missing): this database requires every serving replica to have ${unmet.map(requirementClause).join(", ")}; this build (release ${releaseLine}) does not. ` +
+                "No one-time migration ran and no stored data was changed (the section head only registered this replica and removed registrations of other replicas older than 90 days). " +
+                `Start a build that has ${unmet.map((r) => r.migration).join(", ")}.` +
+                (inForce.length === 0
+                    ? ""
+                    : ` Only to roll back on purpose, after handling the data of that migration: ${inForce.map((m) => `DELETE FROM serving_requirement WHERE migration_id = '${m}';`).join(" ")}`));
+        }
+        case "table_absent":
+            return (`${code} (reason: table_absent): this database has no ${absentTables.join(" / ")} table — the serving requirements recorded there cannot be read, ` +
+                'and an unreadable requirement is not "no requirement", so this build refuses to start. Nothing was written. ' +
+                "Open the store with the public sequence createStoreBackend() → ensureSchema() → runOneTimeMigrations(): ensureSchema() creates these tables.");
+        default: {
+            const unhandled = reason;
+            throw new Error(`stop-then-start-sentence: unknown refusal reason ${String(unhandled)}`);
+        }
+    }
+}
 //# sourceMappingURL=stop-then-start-sentence.js.map

package/dist/plugins/store-backend.d.ts

@@ -467,7 +467,7 @@ export declare function createSqlSessionEraser(db: SqlDriver, opts: RetentionExe
  *  ({@link SQL_BLOB_POSTURE_FACTS})。云形缺 MinIO ⇒ fail-loud(启动了才是假安全);`SNAPSHOT_BLOB_ALLOW_SQL_BYTES=true` =
  *  显式接受 SQL 店 + per-blob 帽(单机/测试台形;pg 上帽只来自 `SNAPSHOT_BLOB_SQL_MAX_BYTES`)。local 后端不经此门(file 店,无 SQL 包墙)。 */
 export declare function assertCloudSnapshotBlobPosture(kind: "mysql" | "pg" | "local", config: Pick<ServiceConfig, "snapshotBlobStore" | "snapshotBlobAllowSql">): void;
-/** SQL 一次性迁移段的输入(两只 SQL 后端同一份;各条目那一半的来源见 `SqlOneTimeMigrationInput`):M32 的车道表 · M40 的判活窗 = 收割器的同一个窗 · M48 的部署形读数(表里那一行)。 */
+/** SQL 一次性迁移段的输入(两只 SQL 后端同一份;各条目那一半的来源见 `SqlOneTimeMigrationInput`):M32 的车道表 · M52 的判活窗(停-迁-起证据的心跳一半)= 收割器的同一个窗 · M48 的部署形读数(表里那一行)。 */
 export declare function buildSqlOneTimeMigrationInput(config: ServiceConfig): SqlOneTimeMigrationInput;
 /**
  * LOCAL backend (clay 2026-06-25 seamless local↔cloud; P0.5 variant-2 + variant-1 file-backed 2026-06-26): a DB-less StoreBackend

package/dist/plugins/store-contracts.d.ts

@@ -339,10 +339,14 @@ export type CreateRunOutcome = {
 };
 /**
  * 认领栅栏交给 `write` 的那一行 run 此刻的事实(SQL = 锁住那一行读的;进程内 = 同步段里读的)。认领与 `running` 只认 taskId,而续跑腿让同一个 taskId
- * 停驻之后回到 `running`、认领仍在 —— 「接下这笔写的那条腿还是不是这条 run 的腿」要按腿问的写者拿它问(今天:副本 `instanceId`,续跑的 CAS 赢点把它改成接手的副本)。
+ * 停驻之后回到 `running`、认领仍在 —— 「接下这笔写的那条腿还是不是这条 run 的腿」要按腿问的写者拿它问:
+ *  · `legId` = 行此刻的持有腿({@link RunRecord.legId},认领铸、交给认领者)。持认领的腿自己的写问「是不是我」—— 判据 {@link createLegCtxClaim},
+ *    与停驻写的 CAS(`setSuspended` / `setNeedsReview`)、撤回(`withdrawMintedRun`)同一只身份读法;
+ *  · `instanceId` = 行此刻的副本。切档口(`routes/run-permission-mode.ts` `switchLegHolds`)问的是「是不是我切过的那条腿」,它手上是本副本活流登记簿里的流对象。
  */
 export interface FencedRun {
     readonly instanceId: string | null;
+    readonly legId: string | null;
 }
 /** SQL 认领栅栏的结局:`held: false` = 认领此刻不是这条 run 的(或它已不在跑),`write` 一次都没调。 */
 export type ClaimFenced<T> = {
@@ -376,7 +380,7 @@ export type ClaimFenceStore = import("./run-store-sql.js").SqlRunStore | InProce
 /**
  * 🔴 [ref] **一笔续跑输入写所凭的那只认领**(检查点店的写口 `putCtx` 交认领的那一形与 `rewriteCtxWhileClaimed` 收它):
  * `fence` = 写者持认领的那只 run 店(栅栏的来源就是认领本身 —— 检查点店不在构造期另绑一份 run 店),`taskId` = 持认领的 run,
- * `legHolds` = 腿判据(在栅栏里对锁住 / 同步段里那一行同步问一次,只读、不许 await)。
+ * `legHolds` = 腿判据(在栅栏里对锁住 / 同步段里那一行同步问一次,只读、不许 await;持认领的腿经 {@link createLegCtxClaim} 按持有腿判)。
  * 装配契约:SQL 检查点店只收同一库上的 SQL run 店(两店出自同一后端;店按判别位 `db` 判 SQL 形且方言同,错形响亮抛),local 检查点店只收进程内栅栏。
  */
 export interface CtxWriteClaim {
@@ -384,6 +388,12 @@ export interface CtxWriteClaim {
     readonly taskId: string;
     readonly legHolds: (run: FencedRun) => boolean;
 }
+/**
+ * 持认领的腿写续跑输入所凭的那只认领(提交腿 `http/submit-ctx.ts` 与续跑腿的写回 `http/resume-legs.ts` 同调这一只):腿判据 = 「被锁那一行此刻的持有腿就是本腿」——
+ * `legId` = 认领交给本腿的那一只(建行 `createRun` 的 `{ ok: true, legId }` / 续跑认领 `markResuming` 的交回值)。同一副本上同一 taskId 被后来的腿重新认领 ⇒
+ * 持有腿已换 ⇒ 零写(副本没变,只问副本的判据分不开这两条腿)。
+ */
+export declare function createLegCtxClaim(fence: ClaimFenceStore, taskId: string, legId: string): CtxWriteClaim;
 /**
  * `RunRecord["status"]`(= `"running" | TaskStatus`)的**唯一分类表** —— 词表的属主 = 判据的属主,
  * 与类型定义同住一个文件。四个类:

package/dist/plugins/store-contracts.js

@@ -30,6 +30,9 @@ export function mintRunLegId() {
     return randomUUID();
 }
 export const FENCE_LANDED = Symbol("in-process-claim-fence.landed");
+export function createLegCtxClaim(fence, taskId, legId) {
+    return { fence, taskId, legHolds: (run) => run.legId === legId };
+}
 export const RUN_STATUS_CLASS = {
     running: "live",
     completed: "succeeded",

package/dist/plugins/tidb-pool.js

@@ -31,6 +31,8 @@ import { RETENTION_LANE_INDEXES } from "./retention-lane-store-sql.js";
 import { LEADER_RUN_INDEXES } from "./leader-run-store-sql.js";
 import { acquireAdvisoryLock, releaseAdvisoryLock } from "./ensure-schema-lock-policy.js";
 import { SKILL_EXEMPTION_CUTOFF_ID, markIfAbsentSql, migrationMarkerDdl } from "./one-time-migration-marker.js";
+import { replicaRegistrationDdl } from "./replica-registration.js";
+import { servingRequirementDdl } from "./serving-requirement.js";
 import { createCloseAwarePool } from "./sql-driver.js";
 export function tidbPoolOptions(tidb) {
     const { host, port, user, password, database, connectionLimit } = tidb;
@@ -780,6 +782,8 @@ export const SCHEMA_STATEMENTS = [
      PRIMARY KEY (pool)
    ) COLLATE utf8mb4_bin`,
     migrationMarkerDdl("mysql"),
+    replicaRegistrationDdl("mysql"),
+    servingRequirementDdl("mysql"),
     ...TIDB_APPROVAL_ASK_STATEMENTS,
     ...TIDB_MEMORY_OPTOUT_GRANT_STATEMENTS,
     ...TIDB_SESSION_CAPTURE_OPTOUT_STATEMENTS,

package/dist/process-instance.d.ts

@@ -0,0 +1,3 @@
+/** 本进程的身份(第一次调用时铸,之后恒同值)。 */
+export declare function processInstanceId(): string;
+//# sourceMappingURL=process-instance.d.ts.map

package/dist/process-instance.js

@@ -0,0 +1,7 @@
+import { uuidv7 } from "@sema-agent/core";
+let minted;
+export function processInstanceId() {
+    minted ??= uuidv7();
+    return minted;
+}
+//# sourceMappingURL=process-instance.js.map

package/dist/project-context.d.ts

@@ -0,0 +1,66 @@
+import { type ProjectRegistration } from "@sema-agent/settings-schema";
+import type { ListFilter } from "./owner-faces.js";
+/** 进简报 / 进 `cwd` 的登记字段(闭集)。每一格的写角色不低于 `prompts` 域(`test/project-context-inheritance.test.ts` 按 settings-schema 的 `writeRoleFor` 钉);身份字段永不在表里。 */
+export declare const PROJECT_BRIEF_FIELDS: readonly ["goal", "notes", "contextItems"];
+/** 进简报 / 进 `cwd` 的登记字段。 */
+export type ProjectBriefField = (typeof PROJECT_BRIEF_FIELDS)[number];
+/** 内容证明:配置中心写口在一次按写权表判过内容字段的写之后盖的时刻(写角色同为 publisher)。本服务只读在不在。 */
+export declare const PROJECT_CONTENT_ATTESTATION_FIELD: "contentAttestedAt";
+/** 继承判读得到的登记成员(类型上只够得着表内字段 + 可见性的属主键 + 内容证明)。 */
+export type ProjectContextSource = Pick<ProjectRegistration, ProjectBriefField | "registeredBy" | typeof PROJECT_CONTENT_ATTESTATION_FIELD>;
+/** 一条 run 继承到的项目上下文(冻结记录;随 run 落进续跑重建输入,续跑腿原样重放)。 */
+export interface ProjectContext {
+    /** 判出它的项目(登记簿键,小写)。 */
+    readonly projectId: string;
+    /** 继承的工作目录:第一条 `folder` 条目 —— 只在射程内(`callerOwnsWorkerDisk`)且请求没带 `cwd` 时在场。 */
+    readonly cwd?: string;
+    /** 项目简报(系统提示追加折叠的第二段);`projectMemory: "disabled"` 或无可列内容 ⇒ 缺席。 */
+    readonly brief?: string;
+}
+/** 继承判的输入(全部是新提交腿此刻读得到的事实)。 */
+export interface ProjectContextInput {
+    /** 这条腿的项目(`legProjectIdOf`);缺席 ⇒ 不继承。 */
+    readonly projectId: string | undefined;
+    /** 本部署的登记簿(`capability-facts.ts` `projectRegistry` 的见证);缺席 = 本部署没有登记簿 ⇒ 不继承。 */
+    readonly registry: Readonly<Record<string, ProjectContextSource>> | undefined;
+    /** 提交者在读面上的视域(读面同一只推导);缺席 = 没有请求 ⇒ 不继承。 */
+    readonly viewer: ListFilter | undefined;
+    /** 部署形表行 `callerOwnsWorkerDisk`:路径条目(继承 `cwd`、简报的路径两段)只在它成立时兑现。 */
+    readonly pathsHonored: boolean;
+    /** 请求体带了 `cwd`(非空串)⇒ 显式值赢,不填。 */
+    readonly requestCwd: boolean;
+    /** 请求 `projectMemory: "disabled"` ⇒ 不出简报。 */
+    readonly projectMemoryOff: boolean;
+}
+/** 继承判的答案:继承到的上下文,外加射程外未列的路径条目数(server 侧 warn 只计数,不记路径)。 */
+export interface ProjectContextDecision {
+    readonly context: ProjectContext | undefined;
+    readonly withheldPathItems: number;
+}
+/** 一只登记对这位观者可见吗(读面与继承同调的唯一判):全舰队视域看全部;否则只看 `registeredBy` 恰是自己的。看不见与不存在同答。 */
+export declare function projectVisible(registration: Pick<ProjectRegistration, "registeredBy">, viewer: ListFilter): boolean;
+/**
+ * 项目简报的唯一铸点(纯串;各段缺席不出,全缺席 ⇒ 无简报)。只读 {@link PROJECT_BRIEF_FIELDS};路径两段只在 `pathsHonored` 时出,且只列名字 ——
+ * `file` 条目未附上,段名写明「相关时去读」。首行点名来源与项目 id(不带 `displayName`:身份字段不进提示)。
+ */
+export declare function buildProjectBrief(projectId: string, registration: Pick<ProjectRegistration, ProjectBriefField>, pathsHonored: boolean): string | undefined;
+/**
+ * 继承判(唯一;调用点只有装配器头部的新提交腿)。项目缺席 / 本部署无登记簿 / 没有观者 / 未登记 / 看不见 / 无内容证明 ⇒ 不继承(不拒,与随机 id 同答)。
+ */
+export declare function projectContextOf(input: ProjectContextInput): ProjectContextDecision;
+/** 续跑重建输入里冻结的那一份的读数:缺席(没继承 / 7.150.0 之前写下的行)· 读得出 · 形不对。 */
+export type FrozenProjectContextReading = {
+    readonly kind: "absent";
+} | {
+    readonly kind: "ok";
+    readonly context: ProjectContext;
+} | {
+    readonly kind: "malformed";
+};
+/**
+ * 冻结的那一份的**唯一读法**(读者 = `http/resume-ctx-read.ts` 的续跑上下文读口)。服务端写下的形是闭集(本文件 {@link projectContextOf} 铸、`buildCheckpointCtx` 原样落盘):
+ * 自有键只在 `projectId` / `cwd` / `brief` 里;`projectId` = 规范小写 UUID;`cwd` 在场 = 宿主绝对路径;`brief` 在场 = 非空串、不超过系统提示追加折叠的帽;
+ * `cwd` 与 `brief` 至少其一(都缺的不会被冻结)。别的形 ⇒ `malformed`(读口答坏体:续跑不重放它、不登记它的 `cwd`)。
+ */
+export declare function frozenProjectContextOf(stored: unknown): FrozenProjectContextReading;
+//# sourceMappingURL=project-context.d.ts.map

package/dist/project-context.js

@@ -0,0 +1,70 @@
+import { PROJECT_ID_REGEX } from "@sema-agent/core";
+import { isAbsoluteHostPath } from "@sema-agent/settings-schema";
+import { MAX_SETTINGS_OUTPUT_STYLE_CHARS } from "./task-settings.js";
+export const PROJECT_BRIEF_FIELDS = ["goal", "notes", "contextItems"];
+export const PROJECT_CONTENT_ATTESTATION_FIELD = "contentAttestedAt";
+export function projectVisible(registration, viewer) {
+    return viewer.fleetWide || registration.registeredBy === viewer.gateOwner;
+}
+export function buildProjectBrief(projectId, registration, pathsHonored) {
+    const sections = [];
+    if (registration.goal !== undefined && registration.goal.length > 0)
+        sections.push(`## Goal\n${registration.goal}`);
+    if (registration.notes !== undefined && registration.notes.length > 0)
+        sections.push(`## Notes\n${registration.notes}`);
+    const items = registration.contextItems ?? [];
+    const notes = items.flatMap((item) => (item.kind === "note" && item.value.length > 0 ? [item.value] : []));
+    if (notes.length > 0)
+        sections.push(`## Project notes\n${notes.join("\n\n")}`);
+    if (pathsHonored) {
+        const folders = items.flatMap((item) => (item.kind === "folder" ? [`- ${item.value}`] : []));
+        if (folders.length > 0)
+            sections.push(`## Project folders\n${folders.join("\n")}`);
+        const files = items.flatMap((item) => (item.kind === "file" ? [`- ${item.value}`] : []));
+        if (files.length > 0)
+            sections.push(`## Project files (not attached — read them when relevant)\n${files.join("\n")}`);
+    }
+    if (sections.length === 0)
+        return undefined;
+    return [`# Project context (from this deployment's project registry; project ${projectId})`, ...sections].join("\n\n");
+}
+export function projectContextOf(input) {
+    const { projectId, registry, viewer } = input;
+    if (projectId === undefined || registry === undefined || viewer === undefined)
+        return { context: undefined, withheldPathItems: 0 };
+    const registration = Object.hasOwn(registry, projectId) ? registry[projectId] : undefined;
+    if (registration === undefined || !projectVisible(registration, viewer))
+        return { context: undefined, withheldPathItems: 0 };
+    if (registration[PROJECT_CONTENT_ATTESTATION_FIELD] === undefined)
+        return { context: undefined, withheldPathItems: 0 };
+    const items = registration.contextItems ?? [];
+    const withheldPathItems = input.pathsHonored ? 0 : items.filter((item) => item.kind !== "note").length;
+    const firstFolder = input.pathsHonored ? items.find((item) => item.kind === "folder")?.value : undefined;
+    const cwd = input.requestCwd ? undefined : firstFolder;
+    const brief = input.projectMemoryOff ? undefined : buildProjectBrief(projectId, registration, input.pathsHonored);
+    if (cwd === undefined && brief === undefined)
+        return { context: undefined, withheldPathItems };
+    return { context: { projectId, ...(cwd !== undefined ? { cwd } : {}), ...(brief !== undefined ? { brief } : {}) }, withheldPathItems };
+}
+export function frozenProjectContextOf(stored) {
+    if (stored === undefined)
+        return { kind: "absent" };
+    if (typeof stored !== "object" || stored === null || Array.isArray(stored))
+        return { kind: "malformed" };
+    if (!Object.keys(stored).every((k) => k === "projectId" || k === "cwd" || k === "brief"))
+        return { kind: "malformed" };
+    const own = (k) => (Object.hasOwn(stored, k) ? stored[k] : undefined);
+    const projectId = own("projectId");
+    const cwd = own("cwd");
+    const brief = own("brief");
+    if (typeof projectId !== "string" || !PROJECT_ID_REGEX.test(projectId) || projectId !== projectId.toLowerCase())
+        return { kind: "malformed" };
+    if (cwd !== undefined && (typeof cwd !== "string" || !isAbsoluteHostPath(cwd)))
+        return { kind: "malformed" };
+    if (brief !== undefined && (typeof brief !== "string" || brief.length === 0 || brief.length > MAX_SETTINGS_OUTPUT_STYLE_CHARS))
+        return { kind: "malformed" };
+    if (cwd === undefined && brief === undefined)
+        return { kind: "malformed" };
+    return { kind: "ok", context: { projectId, ...(cwd !== undefined ? { cwd } : {}), ...(brief !== undefined ? { brief } : {}) } };
+}
+//# sourceMappingURL=project-context.js.map

package/dist/question.d.ts

@@ -9,15 +9,15 @@ export interface QuestionFrame {
     /** "question" only: the model's structured questions, secret-redacted. UNTRUSTED-for-display (shell renders; never
      *  re-feeds a model). Absent on an over-cap payload (the ask then reports unavailable — no frame is emitted at all). */
     questions?: AskQuestion[];
-    /** "question_complete" only: whether the human answered (`answered`) or the ask was released unanswered
-     *  (`unanswered` — ttl/abort → core was told nobody was reachable). Cosmetic dialog-dismiss. */
+    /** "question_complete" only: whether the human answered (`answered`) or the ask closed without an answer
+     *  (`unanswered` — window elapsed / abort / leg-exit sweep). Cosmetic dialog-dismiss. */
     outcome?: "answered" | "unanswered";
     /** Server-signed emit timestamp (additive, [ref]§五→[ref]). Server-minted side-frame ⇒ no core-stream
      *  `eventId` to carry (absence is honest); this is the frame's own time coordinate. */
     serverNowMs?: number;
     /** "question" only ([ref]③, additive, the `tool_approval` window-trio precedent from [ref]): the
-     *  coordinator's OWN answer window (`QUESTION_TTL_MS`, default 5min) — at expiry the ask releases
-     *  UNAVAILABLE ("unanswered") and core adjudicates park-vs-continue. Minted from the SAME `ttlMs` the
+     *  coordinator's OWN answer window (`QUESTION_TTL_MS`, default 5min) — at expiry the ask closes ("unanswered"); core hears
+     *  a delivery failure when a live face presented the card, `unavailable` otherwise ({@link seamOutcomeOf}). Minted from the SAME `ttlMs` the
      *  `setTimeout` below actually arms (single source; a shell countdown rendered from these can never
      *  disagree with the release). Relative + absolute + `serverNowMs` above = clock-skew-proof trio. */
     expiresInMs?: number;
@@ -30,9 +30,7 @@ export interface QuestionFrame {
  *  awaiting a human when the run aborts.
  *
  *  The ledger carries the CARD, not the answer door: `POST /v1/questions/:id/respond` stays live-only (this replica's
- *  memory, `ttlMs`), so a replayed card is answerable only until its own `expiresAtMs` and only on this replica.
- *  The adjudication probe ({@link QuestionCoordinator.hasLiveContext}) reads the same transport's `reachable()` — one
- *  reading of "can this leg's face show a card right now?". */
+ *  memory, `ttlMs`), so a replayed card is answerable only until its own `expiresAtMs` and only on this replica. */
 export interface QuestionRunContext {
     taskId: string;
     owner: string | null;
@@ -73,12 +71,11 @@ export declare class QuestionCoordinator {
     private readonly throttle;
     constructor(throttle?: QuestionThrottle);
     /** Run `fn` with the per-run question context ambient. On exit, release any still-pending question for this run (a
-     *  live-only question cannot outlive its leg → unavailable) and drop the run's counters (no leak). */
+     *  live-only question cannot outlive its leg → released) and drop the run's counters (no leak). */
     runWithContext<T>(ctx: QuestionRunContext, fn: () => Promise<T>): Promise<T>;
-    /** `RunnerDeps.onQuestion`. core calls this when the agent's AskUserQuestion tool fires; the resolved outcome is what
-     *  core acts on — a {@link QuestionAnswer} ONLY when a human really answered, otherwise `{kind:"unavailable"}` (core
-     *  then parks on a durable leg / continues with the `declined_unavailable` card on a non-durable one; either way the
-     *  run never hangs). Arrow property so it can be passed as `onQuestion: coordinator.question` with `this` bound. */
+    /** `RunnerDeps.onQuestion`. core calls this when the agent's AskUserQuestion tool fires; what it settles to is what core
+     *  acts on — a {@link QuestionAnswer} ONLY when a human really answered; a THROW when a live face presented the card and its
+     *  window elapsed unanswered; `{kind:"unavailable"}` otherwise ({@link seamOutcomeOf}). Either way the run never hangs. Arrow property so it can be passed as `onQuestion: coordinator.question` with `this` bound. */
     question: (req: AskQuestionRequest, signal?: AbortSignal) => Promise<OnQuestionOutcome>;
     /** `POST /v1/questions/:id/respond` — resolve a parked question with the shell's answer. Owner-gated with a 404 (no
      *  existence oracle): a non-owner AND an unknown id (answered / expired / wrong replica) both get 404. Returns the
@@ -89,15 +86,6 @@ export declare class QuestionCoordinator {
     };
     /** Test/observability hook: number of currently-parked questions. */
     pendingCount(): number;
-    /** [ref] ([ref] 案二):durable 部署上的 AskUserQuestion 判决探针——本调用点是否处在某条**投递得到人的**
-     *  活流腿上(runWithContext 包裹的 bg/SSE 腿=true;sync /v1/tasks、verify/cascade、durable resume 驱动=false)。
-     *  resolve-spec 的 durable question policy 用它在**判决时**分腿:有活流 ⇒ allow(问活人),无 ⇒
-     *  ask(durable park)。ALS 让这个判断天然 per-leg,policy 组装期不必预知腿别。
-     *  🔴 判据是「投递面此刻可达」而不只是「ALS 在场」(复审 A1):detach 腿断连后 run 仍在本作用域里跑,
-     *  只判 ALS 会把一条谁也收不到的问题判成 allow;park 才是它该走的腿。读的是本腿传输的 `reachable()`
-     *  (有直写面 ⇒ 直写此刻活着;只有账本 ⇒ 恒真,后台腿的 durable events tail 语义;谓词读不出 ⇒ 假,判决面 fail-closed 到 park)。
-     *  只服务判决面:判决放行之后的开帧投递只读传输律(有账本的腿上死直写 = 卡在账本里,送到)。 */
-    hasLiveContext(): boolean;
     private countersFor;
 }
 //# sourceMappingURL=question.d.ts.map

package/dist/question.js

@@ -12,6 +12,20 @@ export const DEFAULT_QUESTION_THROTTLE = {
     ttlMs: 5 * 60_000,
 };
 const UNAVAILABLE = Object.freeze({ kind: "unavailable" });
+const RELEASED = Object.freeze({ kind: "released" });
+const WINDOW_ELAPSED = Object.freeze({ kind: "window_elapsed" });
+function seamOutcomeOf(settlement, presentedLive, ttlMs) {
+    switch (settlement.kind) {
+        case "answered":
+            return settlement.answer;
+        case "released":
+            return UNAVAILABLE;
+        case "window_elapsed":
+            if (!presentedLive)
+                return UNAVAILABLE;
+            throw new Error(`the question was shown on this run's live stream and nobody answered it within its ${ttlMs / 1000}s answer window`);
+    }
+}
 export function parseQuestionResponse(body) {
     if (body === null || typeof body !== "object" || Array.isArray(body))
         return { ok: false, error: "body must be an object" };
@@ -61,7 +75,7 @@ export class QuestionCoordinator {
             finally {
                 for (const [, p] of [...this.pending]) {
                     if (p.taskId === ctx.taskId)
-                        p.settle(UNAVAILABLE, "unanswered");
+                        p.settle(RELEASED);
                 }
                 this.counters.delete(ctx.taskId);
             }
@@ -83,9 +97,9 @@ export class QuestionCoordinator {
         rc.inflight += 1;
         let done = false;
         let timer;
-        let resolveAnswer;
-        const answerP = new Promise((resolve) => { resolveAnswer = resolve; });
-        const settle = (a, outcome) => {
+        let resolveSettled;
+        const settledP = new Promise((resolve) => { resolveSettled = resolve; });
+        const settle = (s) => {
             if (done)
                 return;
             done = true;
@@ -95,12 +109,10 @@ export class QuestionCoordinator {
             ctx.abortSignal?.removeEventListener("abort", onAbort);
             this.pending.delete(id);
             rc.inflight = Math.max(0, rc.inflight - 1);
-            lastOutcome = outcome;
-            resolveAnswer(a);
+            resolveSettled(s);
         };
-        let lastOutcome = "unanswered";
-        const onAbort = () => settle(UNAVAILABLE, "unanswered");
-        timer = setTimeout(() => settle(UNAVAILABLE, "unanswered"), this.throttle.ttlMs);
+        const onAbort = () => settle(RELEASED);
+        timer = setTimeout(() => settle(WINDOW_ELAPSED), this.throttle.ttlMs);
         timer.unref?.();
         signal?.addEventListener("abort", onAbort, { once: true });
         ctx.abortSignal?.addEventListener("abort", onAbort, { once: true });
@@ -108,7 +120,7 @@ export class QuestionCoordinator {
         const now = Date.now();
         const race = createHitlOpenRace({
             targets: [{ transport: ctx.transport, frame: { type: "question", questionId: id, questions, serverNowMs: now, expiresInMs: this.throttle.ttlMs, expiresAtMs: now + this.throttle.ttlMs } }],
-            settled: answerP,
+            settled: settledP,
         });
         const phase = await race.phase;
         if (phase === "delivered") {
@@ -116,7 +128,7 @@ export class QuestionCoordinator {
         }
         else if (phase === "undelivered") {
             recordFailOpen("server.question.open-frame-undelivered", `question=${id}`);
-            settle(UNAVAILABLE, "unanswered");
+            settle(RELEASED);
         }
         else {
             void race.landing.then((late) => {
@@ -126,9 +138,10 @@ export class QuestionCoordinator {
                     recordFailOpen("server.question.open-frame-undelivered", `question=${id}`);
             });
         }
-        const answer = await answerP;
-        race.close({ type: "question_complete", questionId: id, outcome: lastOutcome, serverNowMs: Date.now() });
-        return answer;
+        const settlement = await settledP;
+        race.close({ type: "question_complete", questionId: id, outcome: settlement.kind === "answered" ? "answered" : "unanswered", serverNowMs: Date.now() });
+        const presentedLive = settlement.kind === "window_elapsed" && phase === "delivered" && (await race.acceptedLive(0));
+        return seamOutcomeOf(settlement, presentedLive, this.throttle.ttlMs);
     };
     respond(id, principal, body) {
         const parsed = parseQuestionResponse(body);
@@ -138,16 +151,12 @@ export class QuestionCoordinator {
         if (!entry || !keyAdmits("ask.answer", { subject: recoveredSubject(principal), operator: false }, ownerCellOf(entry.owner))) {
             return { status: 404, body: refusalBody({ errorCode: "question.not_pending", message: "no pending question for this id (answered, expired, or not on this replica)" }) };
         }
-        entry.settle(parsed.value, "answered");
+        entry.settle({ kind: "answered", answer: parsed.value });
         return { status: 200, body: { questionId: id, delivery: "applied" } };
     }
     pendingCount() {
         return this.pending.size;
     }
-    hasLiveContext() {
-        const ctx = this.als.getStore();
-        return ctx !== undefined && ctx.transport.reachable();
-    }
     countersFor(taskId) {
         let rc = this.counters.get(taskId);
         if (!rc) {

package/dist/run-cancel-card.d.ts

@@ -15,7 +15,7 @@ import type { CheckpointToken } from "@sema-agent/core";
 import type { CheckpointStoreFull, RunStore } from "./plugins/store-backend.js";
 /** 取消动词在 `runSessionId` 这条 run 的会话上会结算的那一张卡;没有 ⇒ `null`。 */
 export declare function runCancelCardOf(cs: Pick<CheckpointStoreFull, "findPendingTokenBySession">, runSessionId: string): Promise<CheckpointToken | null>;
-/** 取消动词要问的 run 行的两口:这条会话上持着认领的 run、它的行。 */
+/** 取消动词要问的 run 行的两口:这条会话上持着认领的 run、它的状态(不带属主的一格事实,只经属主存取器读)。 */
 export type CancelRunReader = Pick<RunStore, "getActiveTaskId" | "getRun">;
 /**
  * 取消动词会不会结算 `token` 这一张 —— 出路投影问的就是这一问,三个条件都是取消口自己的:

package/dist/run-cancel-card.js

@@ -1,5 +1,6 @@
 import { LIVE_RUN_GATE_KINDS } from "./plugins/checkpoint-store-face.js";
 import { isParkedRunStatus } from "./plugins/store-contracts.js";
+import { runFactsOf } from "./http/owner-access.js";
 const RUN_CANCEL_CARD = { gateKinds: LIVE_RUN_GATE_KINDS, axis: "run" };
 export function runCancelCardOf(cs, runSessionId) {
     return cs.findPendingTokenBySession(runSessionId, undefined, RUN_CANCEL_CARD);
@@ -13,7 +14,7 @@ export async function cancelSettlesCard(cs, runs, token) {
     const holder = await runs.getActiveTaskId(host);
     if (holder === undefined)
         return false;
-    const run = await runs.getRun(holder);
+    const run = await runFactsOf(runs, holder);
     return run !== undefined && isParkedRunStatus(run.status) && (await runCancelCardOf(cs, host)) === token;
 }
 //# sourceMappingURL=run-cancel-card.js.map

package/dist/security.d.ts

@@ -135,7 +135,7 @@ export type OwnerAwareSessionStore = SessionStore & {
     register?: (sessionId: string, owner: string | null) => Promise<void>;
     /** [ref] placed 分区的元组读口(店的既有读口,一行 PK 读;`undefined` = 普通会话或无此行)。店不交它 = 不实现 placement = 没有 placed 行(无 repo 的内存店)。两个读者:
      *  ① 会话面的属主门只在属主为 NULL 时读它一次(无主的 placed 行不是公共行,`http/principal-gate.ts` 的 `sessionOwnerCellOf`);
-     *  ② `agent` 的唯一读口 `session-agent.ts` 的 `readSessionAgent`(会话视图体顶层、运维审批队列的停驻行同读):店没有这一面 ⇒ 键缺席,读面不凭别处另铸子代身份。 */
+     *  ② `agent` 的唯一读口 `http/owner-access.ts` 的 `readSessionAgent`(会话视图体顶层、运维审批队列的停驻行同读):店没有这一面 ⇒ 键缺席,读面不凭别处另铸子代身份。 */
     placementOf?: (sessionId: string) => Promise<SessionPlacementRecord | undefined>;
     /** E16 — enumerate the caller's sessions (owner-filtered on the session store's OWN owner column).
      *  `includeUnowned` = [ref] 窄互认第二臂的**第三条件**(`owner IS NULL`)的 SQL 承载位:置真时

package/dist/session-agent.d.ts

@@ -5,7 +5,7 @@
  * 店原样记下,首写不可变。三只持久会话店都存:SQL 两孪生在 `session_meta` 的 `placement_*` 列(`plugins/session-placement.ts` 的 `placementFromRow`),
  * local 后端(7.141.0 起)在会话存档行头(core 文件 repo)。读口是店的 `placementOf`(一行 PK 探针;店不交它 = 不存元组)。
  *
- * 读者(同一只读口 {@link readSessionAgent}、同一只投影 {@link sessionAgentOf},逐值同答):
+ * 读者(同一只读口 —— 属主存取器的 `readSessionAgent`(`http/owner-access.ts`:店的行读只在存取器里)—— 同一只投影 {@link sessionAgentOf},逐值同答):
  *  · 会话视图 `GET /v1/sessions/:id` 体顶层的 `agent`(视图读才付探针;探针抛 ⇒ 视图读响亮失败,`boot/session-faces.ts`);
  *  · 运维审批队列 `GET /v1/approvals` 的停驻行(`pending[]` 的 `checkpoint` 族)与 `/v1/approvals/stream` 的 `pending` 帧:行的身份就是它那只会话
  *    (决断口 `/v1/approvals/:sessionId/decide`),行上的 `agent` = 同一只会话在视图上的 `agent`;一行读不出 ⇒ 只这一行缺键、F 类兜底计数
@@ -26,15 +26,6 @@ export interface SessionAgent {
     parentSessionId?: string;
     rootSessionId?: string;
 }
-/** 交委派元组读口的会话店面(本仓三只持久会话店与缓存包装层都交;内存店不交)。 */
-export interface PlacementReadingSessionStore {
-    readonly placementOf?: (sessionId: string) => Promise<SessionPlacementRecord | undefined>;
-}
 /** {@link SessionAgent} 的唯一投影:店答出的委派元组 → `agent` 的值;`undefined`(普通会话 / 店没有这一面)⇒ 调用方不铸键。 */
 export declare function sessionAgentOf(placement: SessionPlacementRecord | undefined): SessionAgent | undefined;
-/**
- * `agent` 的**唯一读口**:店的 `placementOf` 一读 → {@link sessionAgentOf}。店不交 `placementOf` ⇒ `undefined`(这台部署不存元组,不探)。
- * 探针抛 ⇒ 原样上抛 —— 读不出怎么说归读者(视图读响亮失败;队列只缺那一行的键并计数),本函数不替任何一面把故障说成「不是子代」。
- */
-export declare function readSessionAgent(store: PlacementReadingSessionStore | undefined, sessionId: string): Promise<SessionAgent | undefined>;
 //# sourceMappingURL=session-agent.d.ts.map

package/dist/session-agent.js

@@ -7,10 +7,4 @@ export function sessionAgentOf(placement) {
         ...(placement.rootSessionId !== undefined ? { rootSessionId: placement.rootSessionId } : {}),
     };
 }
-export async function readSessionAgent(store, sessionId) {
-    const placementOf = store?.placementOf;
-    if (placementOf === undefined)
-        return undefined;
-    return sessionAgentOf(await placementOf.call(store, sessionId));
-}
 //# sourceMappingURL=session-agent.js.map