@sema-agent/server 7.145.0 → 7.146.0

package/dist/plugins/sql-json-column.d.ts

@@ -69,7 +69,7 @@ export interface JsonColumnMember {
  *
  * 🔴 存在的唯一理由是「别名位在那里不合法」,**不是**给读腿留第二条路:读腿一律用 {@link jsonColumnText}
  * (别名是它的产物的一部分,理由见那只函数)。今天整仓**三处**消费方,各自的「别名位不合法」都是真的:
- *  · `one-time-migrations.ts` 的几条改写(M8 / M17 / M18 / M21 的候选扫描与按原文 CAS 回写)——
+ *  · `one-time-migrations.ts` 的几条改写(M17 / M18 / M21 的候选扫描与按原文 CAS 回写)——
  *    它们要在 `WHERE` 里判这一列的**文本**,而 `WHERE` 没有别名位;
  *  · `workflow-journal-store-sql.ts` 的 `loadPage`([ref] 车③a)—— 那一列的投影裹在一条
  *    `CASE WHEN LENGTH(result) > ? THEN NULL ELSE <expr> END AS result_json` 里:**别名属于整条 CASE**
@@ -202,6 +202,10 @@ export declare class StoreCorruptError extends Error {
     /** 出事的坐标(`<table>.<column> for <identity>`,由 {@link SqlJsonColumnError.where} 原样带过来)——
      *  进 wire 的 `where` 字段,人按它去找那一行。 */
     readonly where: string;
+    /** 构造函数交进来的就是这一只列错误(类型面如实:折码只在体问题上产出本类,见 {@link foldJsonColumn});子类想在同一份因由上再带一格事实时按它再构造,不必断言。 */
+    readonly cause: SqlJsonColumnError & {
+        readonly problem: SqlJsonColumnBodyProblem;
+    };
     constructor(cause: SqlJsonColumnError & {
         readonly problem: SqlJsonColumnBodyProblem;
     }, sentence: string);

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

@@ -20,7 +20,7 @@ import { TiDBResumeAnchorStore, PgResumeAnchorStore } from "./resume-anchor-stor
 import { type SessionPolicyStoreLogger } from "../stores-sql/session-policy-store-sql.js";
 import type { ServiceConfig } from "../config-types.js";
 import { TiDBRunStore, PgRunStore } from "./run-store-sql.js";
-import { TiDBCheckpointStore, PgCheckpointStore } from "./checkpoint-store-sql.js";
+import { TiDBCheckpointStore, PgCheckpointStore } from "../stores-sql/checkpoint-store-sql.js";
 import { TiDBImageIndex, PgImageIndex } from "./image-index-sql.js";
 import { TiDBImageBake, PgImageBake } from "./image-bake-store-sql.js";
 import { TiDBLeaderRunStore, PgLeaderRunStore } from "./leader-run-store-sql.js";
@@ -92,7 +92,7 @@ export type ServiceFileHistoryStore = FileHistoryStore & {
      *  protected — never a synchronous external-store delete). Reaper-driven; SQL twins only. */
     sweepOrphanBlobs?(): Promise<number>;
 };
-/** SVC-2 (core CORE-7) WorkflowJournalStore — core's interface PLUS the service `deleteByRun` (GC extra). tidb/pg =
+/** SVC-2 (core CORE-7) WorkflowJournalStore — core's interface PLUS the service read page and age sweep below. tidb/pg =
  *  durable SQL twins (cross-replica resume journal); local = the service {@link FileWorkflowJournalStore}
  *  (single-box but RESTART-durable crash-safe JSONL, replacing core's InMemory). The shared equivalence suite keeps
  *  all three byte-matched (scope guard / idempotent-per-ordinal / oversize **refusal** —— [ref] / core 7.12.0
@@ -111,11 +111,14 @@ export type ServiceWorkflowJournalStore = WorkflowJournalStore & {
         resultJson: string | null;
         resultBytes: number;
     }>>;
-    deleteByRun?(runId: string): Promise<number>;
-    /** SVC-2 GC sweep (durable twins only): purge entries older than `maxAgeMs` — wired into the reaper to bound the
-     *  TaskResult-bearing table (the per-run deleteByRun has no run-store reap hook). Local InMemory omits it. */
+    /** SVC-2 GC sweep (durable twins only): purge entries older than `maxAgeMs` — the `workflow-journal-expired` leg of the backend sweep verb
+     *  (`plugins/store-sweep.ts`, composed in `boot/stores.ts`) bounds the TaskResult-bearing table with it; the journal's one delete path (no per-run
+     *  delete: the engine contract never had one). Local File / InMemory omit it. */
     reapExpired?(now: number, maxAgeMs: number): Promise<number>;
 };
+/** 本部署有没有 workflow journal 店、是哪一只 —— 唯一读法:开了 self-orchestration 且有后端 ⇒ 后端的 journal 店,否则无。
+ *  两处读者同读它:workflow 编排段(交 Runner 与 journal HTTP 读面的那只)与持久层组合点(按龄清扫动词的 `workflow-journal-expired` 腿)。 */
+export declare function workflowJournalOf(config: Pick<ServiceConfig, "selfOrchestrationEnabled">, backend: Pick<StoreBackend, "workflowJournal"> | undefined): ServiceWorkflowJournalStore | undefined;
 export type ImageIndex = TiDBImageIndex | PgImageIndex;
 export type ImageBake = TiDBImageBake | PgImageBake;
 /** [ref] 车4 件1:durable leader-run 登记表的双方言孪生(union 同族——TS 私有字段让具体类名义上不同)。 */
@@ -280,9 +283,9 @@ export interface StoreBackend {
      *  until a 2026-07-25 doc-rot sweep caught it). core 1.145.0 added the seam this comment was waiting for:
      *  `RunnerDeps.workflowJournalStore` (now `@sema-agent/core` `dist/core/types.d.ts`) + `journalStore` on the
      *  run_workflow tool deps (`dist/orchestration/run-workflow-tool.d.ts`), and the boot chain consumes it
-     *  end-to-end: built in `boot/workflow-orchestration.ts` (`const workflowJournalStore = …backend.workflowJournal()`),
-     *  threaded into RunnerDeps (`boot/runner-deps.ts` 的 `workflowJournalStore`), reaped on the maintenance tick
-     *  (`boot/reapers.ts` 同名字段), and read by `GET /v1/workflows/:id/journal` (`http/routes/workflows.ts`, [ref]). */
+     *  end-to-end: selected by {@link workflowJournalOf} (self-orchestration on ∧ a backend), built in `boot/workflow-orchestration.ts`,
+     *  threaded into RunnerDeps (`boot/runner-deps.ts` 的 `workflowJournalStore`), aged out by the backend sweep verb's `workflow-journal-expired`
+     *  leg (`boot/stores.ts`, same selector), and read by `GET /v1/workflows/:id/journal` (`http/routes/workflows.ts`, [ref]). */
     workflowJournal(): ServiceWorkflowJournalStore;
     /** [ref] §1 consumption sink for `RunnerDeps.onTaskOutcome` facts. REQUIRED on all backends:
      *  tidb/pg = the outcome-ledger twins (SQL rows, mapped via coreOutcomeToLedgerRow + verbatim core_outcome

package/dist/plugins/store-backend.js

@@ -33,7 +33,7 @@ import { FileUserInputLedgerStore } from "./user-input-ledger-file.js";
 import { TiDBUserInputLedgerStore, PgUserInputLedgerStore } from "./user-input-ledger-sql.js";
 import { TiDBResumeAnchorStore, PgResumeAnchorStore } from "./resume-anchor-store-sql.js";
 import { TiDBSessionPolicyStore, PgSessionPolicyStore } from "../stores-sql/session-policy-store-sql.js";
-import { TiDBWorkflowJournalStore, PgWorkflowJournalStore } from "./workflow-journal-store-sql.js";
+import { TiDBWorkflowJournalStore, PgWorkflowJournalStore } from "../stores-sql/workflow-journal-store-sql.js";
 import { TiDBFileHistoryStore, PgFileHistoryStore, FILE_HISTORY_BLOB_TABLE, FILE_HISTORY_BLOB_KEY_PREFIX } from "./file-history-store-sql.js";
 import { MinioBlobBackend, SqlBlobBackend } from "./blob-backend.js";
 import { buildDisplaySafeUrl } from "../trace/redact.js";
@@ -41,8 +41,8 @@ import { fileMemoryControlDirFor } from "../memory-scope.js";
 import { createTidbPool, ensureSchema as ensureTidbSchema } from "./tidb-pool.js";
 import { createPgPool, ensurePgSchema, pgPoolOptions } from "./pg-pool.js";
 import { TiDBRunStore, PgRunStore } from "./run-store-sql.js";
-import { TiDBCheckpointStore, PgCheckpointStore } from "./checkpoint-store-sql.js";
-import { TiDBToolResultStore, PgToolResultStore } from "./tool-result-store-sql.js";
+import { TiDBCheckpointStore, PgCheckpointStore } from "../stores-sql/checkpoint-store-sql.js";
+import { TiDBToolResultStore, PgToolResultStore } from "../stores-sql/tool-result-store-sql.js";
 import { TiDBImageIndex, PgImageIndex } from "./image-index-sql.js";
 import { TiDBImageBake, PgImageBake } from "./image-bake-store-sql.js";
 import { TiDBLeaderRunStore, PgLeaderRunStore } from "./leader-run-store-sql.js";
@@ -59,11 +59,14 @@ import { TiDBAdoptionLogStore, PgAdoptionLogStore } from "./adoption-log-sql.js"
 import { TiDBRetentionStore, PgRetentionStore, sqlStoreRetention } from "./retention-store-sql.js";
 import { TiDBRetentionLaneStore, PgRetentionLaneStore } from "./retention-lane-store-sql.js";
 import { createSqlPermissionRuleStores } from "./permission-rule-store-sql.js";
-import { FILE_PERMISSION_RULE_DIR, createFilePermissionRuleStores } from "./permission-rule-store-file.js";
+import { FILE_PERMISSION_RULE_DIR, createFilePermissionRuleStores, fileRuleBucketOwners, isFileBucketDamaged } from "./permission-rule-store-file.js";
 import { retireImportedLayerRootAllows } from "./imported-layer-root-retirement.js";
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
 import { storeDegradedReasonFor } from "../store-posture.js";
 import { openWithinWait } from "./store-open-wait.js";
+export function workflowJournalOf(config, backend) {
+    return config.selfOrchestrationEnabled && backend ? backend.workflowJournal() : undefined;
+}
 function historyBlobBackend(config, dialect, pool) {
     const s = config.snapshotBlobStore;
     if (!s)
@@ -298,17 +301,15 @@ class LocalBackend {
         await this.sessionStore.settleArchiveSnapshots();
     }
     async runOneTimeMigrations() {
-        const holderDeathCodeRowsBackfilled = this.runStore.migrateLegacyHolderDeathCodes();
         const archives = await this.sessionStore.migrateLocalArchives();
         const placements = await backfillLocalExecutionPlacements(this.runStore.sessionIdsWithRuns(), this.sessionStore.executionPlacementBackfill, { lanes: this.executionLanes });
         const importedLayerRoot = { importedLayerRootAllowsRetired: [], importedLayerRootBucketsSkipped: [] };
         if (existsSync(join(this.fileBackend.root, FILE_PERMISSION_RULE_DIR))) {
             const rules = this.permissionRule();
-            await retireImportedLayerRootAllows({ candidateOwners: () => rules.approvals.importRecordOwners(), durable: rules.durable, isWholeBucketRefusal: () => false, isVanishedBucket: () => false }, importedLayerRoot);
+            await retireImportedLayerRootAllows({ candidateOwners: () => fileRuleBucketOwners(rules), durable: rules.durable, isWholeBucketRefusal: isFileBucketDamaged, isVanishedBucket: () => false }, importedLayerRoot);
         }
         return {
             ...NO_SQL_MIGRATIONS,
-            holderDeathCodeRowsBackfilled,
             executionPlacementsBackfilled: placements.backfilled,
             executionPlacementSessionsUnreadable: placements.unreadable,
             askExecutionLanesBackfilled: backfillLocalAskExecutionLanes(this.approvalAskStore, { lanes: this.executionLanes }),

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

@@ -168,20 +168,10 @@ export declare const RUN_HOLDER_DEATH_CODES: {
     readonly orphaned: "run.orphaned";
 };
 export type RunHolderDeathCode = (typeof RUN_HOLDER_DEATH_CODES)[keyof typeof RUN_HOLDER_DEATH_CODES];
-/**
- * 一次性迁移 **M6** 的判据(窗、删法与删后谁接住:窗口见 `plugins/one-time-migrations.ts` 登记表):7.116.0 之前写下的死亡判决行只有句子、码列为空 ——
- * 该行应有的码。两处用:local 腿的起服写回(`FileRunStore.migrateLegacyHolderDeathCodes`)与 SQL 两孪生行映射里的**读侧半场**(滚动升级窗里旧副本
- * 还会写这种行,起服写回覆盖不到;本函数随 M6 一起删)。只认两句落款的原字节(接管臂括注形按前缀认);码列已有值 / 非 `failed` / 别的句子 ⇒ 原样。
- */
-export declare function readLegacyHolderDeathCode(row: {
-    readonly status: string;
-    readonly error: string | null;
-    readonly errorCode: string | null;
-}): string | null;
 /**
  * run 行上是不是一份**持有者死亡判决**:`failed`,且行上的码是 {@link RUN_HOLDER_DEATH_CODES} 之一。判决只说「持有它的那个进程死在这条腿收场之前」,
  * 不说是谁 —— 持有者是谁读行上的 `instanceId`(判决不改它)。读者 = 用户输入受理账本的收敛判词(`src/user-input-ledger.ts` `judgeOpen`)。
- * 旧行(只有句子)由一次性迁移 M6 补上码(起服写回 + SQL 滚动窗的读侧半场,{@link readLegacyHolderDeathCode}),所以这里不再按句子判。
+ * 只认码、不按句子判:7.116.0 起两只死亡判决的写者恒同写码;只有句子、码列为空的行(更早的写者铸的)不是死亡判决(随包 MIGRATION 写了)。
  * 正常失败(别的码 / 无码)/ park 过期收割(`approval.expired`:腿 park 过)都**不是**死亡判决。
  */
 export declare function isHolderDeathVerdict(run: Pick<RunRecord, "status" | "errorCode">): boolean;

package/dist/plugins/store-contracts.js

@@ -8,15 +8,6 @@ export function buildRunOrphanedError(heldBy) {
 }
 export const RUN_HOLDER_DEATH_CODES = { stalled: "run.stalled", orphaned: "run.orphaned" };
 const RUN_HOLDER_DEATH_CODE_WORDS = new Set(Object.values(RUN_HOLDER_DEATH_CODES));
-export function readLegacyHolderDeathCode(row) {
-    if (row.errorCode !== null || row.status !== "failed" || row.error === null)
-        return row.errorCode;
-    if (row.error === RUN_STALLED_ERROR)
-        return RUN_HOLDER_DEATH_CODES.stalled;
-    if (row.error === RUN_ORPHANED_ERROR || row.error.startsWith(`${RUN_ORPHANED_ERROR} (`))
-        return RUN_HOLDER_DEATH_CODES.orphaned;
-    return null;
-}
 export function isHolderDeathVerdict(run) {
     return run.status === "failed" && run.errorCode !== null && RUN_HOLDER_DEATH_CODE_WORDS.has(run.errorCode);
 }

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

@@ -0,0 +1,63 @@
+/**
+ * 后端级按龄清扫动词 —— 一个后端的按龄清扫只有一只动词 `sweep({ nowMs })`,答每条腿删了几行。
+ *
+ * ## 律(一条)
+ * 维护 tick 只调这一只动词,不逐店探「有没有某个按龄删的方法」;每条腿的界只有一种读法({@link buildStoreSweepBounds}:部署旋钮 → 引擎的词 `maxAgeMs`,
+ * 即工具结果店 `ToolResultStore.reap(now, { maxAgeMs })`、名册 `RosterGcOptions.maxAgeMs` 的那个词;journal 店的按龄删同收 `maxAgeMs`),**每次清扫现读** —— `TOOL_RESULT_TTL_SEC` 是热键,
+ * 改了下一拍就按新值删;没给界的腿,或本后端那只座没有按龄删的面,一行不删、答 0。
+ * 形照引擎 SQL 后端包的同名动词(`SqlStorageBackend.sweep` / `SqlSweepLeg` / `SqlSweepReceipt`):腿名逐字用它的词。
+ *
+ * ## 射程(如实)
+ * 今天的三条腿:`tool-results-aged`(工具结果店的契约成员 `reap`)、`roster-aged`(名册 SQL 孪生的按龄删;File / 内存名册没有这一面 ⇒ 0)与
+ * `workflow-journal-expired`(journal SQL 孪生的按龄删 `reapExpired`,见 {@link createJournalSweepLeg};只在开了 self-orchestration 且有后端时有这只店,
+ * core 的 File journal 店没有这一面 ⇒ 0)。引擎包的腿闭集另有 `file-history-orphan-blobs`,随它的座搬进 `src/stores-sql/` 时并进来;信箱的 `reap` 是按收件箱
+ * 作用域的契约成员,引擎包的清扫腿里没有它,本动词也不收。实现仍是各座自己的方法;目录搬进引擎包之后,SQL 后端的这只动词就是包的 `sweep`。
+ *
+ * ## 失败
+ * 腿互不牵连:一条腿抛(同步抛或拒)不拦别的腿。全腿成功 ⇒ 答回执;有腿失败 ⇒ 以 {@link StoreSweepError} 拒,带上成功腿的计数与失败腿的原因,
+ * 调用方按腿各自上报。
+ */
+import type { ServiceConfig } from "../config.js";
+/** 本后端跑的清扫腿(闭集;词与引擎 SQL 后端包的 `SqlSweepLeg` 同字)。 */
+export declare const STORE_SWEEP_LEGS: readonly ["roster-aged", "tool-results-aged", "workflow-journal-expired"];
+export type StoreSweepLeg = (typeof STORE_SWEEP_LEGS)[number];
+/** 一次清扫每条腿删了几行。 */
+export type StoreSweepReceipt = Readonly<Record<StoreSweepLeg, number>>;
+/** 一条腿的界(部署陈述;词 = 引擎的 `maxAgeMs`)。 */
+export interface StoreSweepBound {
+    readonly maxAgeMs: number;
+}
+/** 各腿的界(缺一条 = 那条腿不删)。 */
+export type StoreSweepBounds = Readonly<Partial<Record<StoreSweepLeg, StoreSweepBound>>>;
+/**
+ * 部署旋钮 → 各腿的界:本仓唯一的读法。`TOOL_RESULT_TTL_SEC`(秒,> 0,热键)→ `tool-results-aged`;`ROSTER_RETENTION_MS`(毫秒,下限 1 分钟)→ `roster-aged`;
+ * `WORKFLOW_JOURNAL_RETENTION_MS`(毫秒,下限 1 分钟)→ `workflow-journal-expired`。
+ * 组合点把它包成读法函数交给 {@link createStoreSweep},每次清扫现读一次 —— 交起服那一刻的值会让热发布的新界不生效。
+ */
+export declare function buildStoreSweepBounds(config: Pick<ServiceConfig, "toolResultTtlSec" | "rosterRetentionMs" | "workflowJournalRetentionMs">): StoreSweepBounds;
+/** 一条腿的实现:删掉存了超过 `bound.maxAgeMs` 的行,答删了几行。 */
+export type StoreSweepLegRun = (nowMs: number, bound: StoreSweepBound) => Promise<number> | number;
+/**
+ * journal 店的按龄删 → `workflow-journal-expired` 腿:截止线 = 动词交来的 `nowMs` − 动词交来的 `maxAgeMs`(界每次清扫现读,腿不自存)。
+ * 店没有这一面(core 的 File / 内存 journal 店)或没有店(self-orchestration 关 / 无后端)⇒ 无腿,动词答 0。
+ */
+export declare function createJournalSweepLeg(store: {
+    reapExpired?(now: number, maxAgeMs: number): Promise<number>;
+} | undefined): StoreSweepLegRun | undefined;
+export interface StoreSweep {
+    sweep(input: {
+        readonly nowMs: number;
+    }): Promise<StoreSweepReceipt>;
+}
+/** 有腿失败的那次清扫:`receipt` 里失败腿记 0,`failed` 按腿带原因。 */
+export declare class StoreSweepError extends Error {
+    readonly receipt: StoreSweepReceipt;
+    readonly failed: ReadonlyMap<StoreSweepLeg, unknown>;
+    constructor(receipt: StoreSweepReceipt, failed: ReadonlyMap<StoreSweepLeg, unknown>);
+}
+export declare function createStoreSweep(spec: {
+    readonly legs: Readonly<Partial<Record<StoreSweepLeg, StoreSweepLegRun>>>;
+    /** 界的读法:每次清扫调一次(只收函数 —— 起服那一刻的界对象交不进来)。 */
+    readonly bounds: () => StoreSweepBounds;
+}): StoreSweep;
+//# sourceMappingURL=store-sweep.d.ts.map

package/dist/plugins/store-sweep.js

@@ -0,0 +1,48 @@
+export const STORE_SWEEP_LEGS = ["roster-aged", "tool-results-aged", "workflow-journal-expired"];
+export function buildStoreSweepBounds(config) {
+    return {
+        "roster-aged": { maxAgeMs: config.rosterRetentionMs },
+        "tool-results-aged": { maxAgeMs: config.toolResultTtlSec * 1000 },
+        "workflow-journal-expired": { maxAgeMs: config.workflowJournalRetentionMs },
+    };
+}
+export function createJournalSweepLeg(store) {
+    const reap = store?.reapExpired?.bind(store);
+    return reap === undefined ? undefined : (nowMs, { maxAgeMs }) => reap(nowMs, maxAgeMs);
+}
+export class StoreSweepError extends Error {
+    receipt;
+    failed;
+    constructor(receipt, failed) {
+        super(`store sweep: leg(s) ${[...failed.keys()].join(", ")} failed`);
+        this.receipt = receipt;
+        this.failed = failed;
+        this.name = "StoreSweepError";
+    }
+}
+export function createStoreSweep(spec) {
+    const runLeg = async (leg, nowMs, bounds) => {
+        const run = spec.legs[leg];
+        const bound = bounds[leg];
+        if (run === undefined || bound === undefined)
+            return { leg, removed: 0 };
+        try {
+            return { leg, removed: await run(nowMs, bound) };
+        }
+        catch (error) {
+            return { leg, error };
+        }
+    };
+    return {
+        async sweep({ nowMs }) {
+            const bounds = spec.bounds();
+            const settled = await Promise.all(STORE_SWEEP_LEGS.map((leg) => runLeg(leg, nowMs, bounds)));
+            const receipt = Object.fromEntries(settled.map((s) => [s.leg, "removed" in s ? s.removed : 0]));
+            const failed = new Map(settled.flatMap((s) => ("error" in s ? [[s.leg, s.error]] : [])));
+            if (failed.size > 0)
+                throw new StoreSweepError(receipt, failed);
+            return receipt;
+        },
+    };
+}
+//# sourceMappingURL=store-sweep.js.map

package/dist/plugins/tidb-pool.js

@@ -16,7 +16,7 @@ import { PRINCIPAL_MAX_UTF8_BYTES } from "../security.js";
 import { ensureIndexes } from "./ensure-index.js";
 import { CENTRAL_SCHEMA_INDEXES } from "./schema-indexes.js";
 import { SESSION_INDEXES } from "./pg-session-storage.js";
-import { TOOL_RESULT_INDEXES } from "./tool-result-store-sql.js";
+import { TOOL_RESULT_INDEXES } from "../stores-sql/tool-result-store-sql.js";
 import { COST_QUOTA_INDEXES } from "./pg-cost-quota.js";
 import { RATE_LIMIT_INDEXES } from "./pg-rate-limiter.js";
 import { OUTCOME_LEDGER_INDEXES } from "./outcome-ledger-sql.js";

package/dist/plugins/tidb-session-store.d.ts

@@ -16,10 +16,10 @@ import { type InstructionSourceBaseline } from "../instruction-source-notice.js"
 import type { SessionWorkspace } from "../session-workspace.js";
 import type { RetentionDeclaration } from "@sema-agent/core";
 import type { SessionSummary } from "./store-contracts.js";
-import { type ClientSessionRowWrite, type ReplaySessionRowWrite, type ReplaySessionRowWriteOutcome, type SessionRowPatch, type SessionRowWriteOutcome } from "../session-row.js";
+import { type ClientSessionRowWrite, type ReplaySessionRowWrite, type ReplaySessionRowWriteOutcome, type SessionRowAnswer, type SessionRowPatch, type SessionRowWriteOutcome } from "../session-row.js";
 import { type PlacementAcquireOpts } from "./session-placement.js";
 import { type StagingHandle } from "../session-sync-kernel.js";
-import { type ForkTarget, type ForkToOutcome } from "./session-fork.js";
+import { type ForkPlacement, type ForkTarget, type ForkToOutcome } from "./session-fork.js";
 import { type ExecutionPlacementSeat } from "../execution-placement.js";
 export declare class TiDBSessionStore implements SessionStore {
     private readonly pool;
@@ -130,6 +130,17 @@ export declare class TiDBSessionStore implements SessionStore {
         limit: number;
         q?: string;
     }): Promise<SessionSummary[]>;
+    /** {@link listSessions} with each row's occupant (owner + incarnation) from the same SELECT — `OwnerAwareSessionStore.listSessionRows`; the incarnation never enters the row. */
+    listSessionRows(opts: {
+        owner?: string;
+        includeUnowned?: boolean;
+        cursor?: {
+            lastActivityAt: string;
+            sessionId: string;
+        };
+        limit: number;
+        q?: string;
+    }): Promise<Array<SessionRowAnswer<SessionSummary>>>;
     /** ONE session's list row — {@link listSessions}' projection (same SELECT, same mapper) scoped to one id; `undefined` = not a
      *  row of the list face (no such session / placed). The run-preview subqueries are scoped to the same id (an index read on
      *  `task_run.session_id`, not the whole-ledger aggregate the list pays). */
@@ -194,7 +205,9 @@ export declare class TiDBSessionStore implements SessionStore {
      * We instead SELECT the entire `session_event` log ordered by seq — every durable entry, compaction floor
      * bypassed — and re-seq it dense from 0 into the new session, ids/parents/payload byte-verbatim.
      */
-    fork(sourceId: string, owner?: string | null): Promise<string | null>;
+    fork(sourceId: string, owner?: string | null, opts?: {
+        placement?: ForkPlacement;
+    }): Promise<string | null>;
     /**
      * **fork 续写的店契约**(三店同一只私有体;core `fork` 是它的投影):把源会话的整份历史拷进调用方给的目标 id。
      *  1. **原子目标创建**:事务首句 `INSERT INTO session_meta (…, fork_key) VALUES (:target, …)`,主键即排他(meta 先,随后拷事件、COMMIT);

package/dist/plugins/tidb-session-store.js

@@ -152,6 +152,9 @@ export class TiDBSessionStore {
         }
     }
     async listSessions(opts) {
+        return (await this.listSessionRows(opts)).map((a) => a.row);
+    }
+    async listSessionRows(opts) {
         const params = [];
         const where = ["sm.placement_kind IS NULL"];
         if (opts.owner !== undefined) {
@@ -166,7 +169,7 @@ export class TiDBSessionStore {
             where.push("(sm.updated_at < ? OR (sm.updated_at = ? AND sm.session_id < ?))");
             params.push(new Date(opts.cursor.lastActivityAt), new Date(opts.cursor.lastActivityAt), opts.cursor.sessionId);
         }
-        return (await this.selectListRows({ where, params, limit: opts.limit })).map((a) => a.row);
+        return this.selectListRows({ where, params, limit: opts.limit });
     }
     async sessionSummaryOf(sessionId) {
         return (await this.listRowOf(sessionId))?.row;
@@ -246,8 +249,8 @@ export class TiDBSessionStore {
     async recordSessionWorkspace(sessionId, incarnation, workspace) {
         await this.pool.query("UPDATE session_meta SET workspace = ? WHERE session_id = ? AND incarnation = ?", [encodeSessionWorkspaceCell(workspace, JSON.stringify, sessionId), sessionId, incarnation]);
     }
-    async fork(sourceId, owner) {
-        return forkByFreshId((s, o, t) => this.forkTo(s, o, t), sourceId, owner);
+    async fork(sourceId, owner, opts) {
+        return forkByFreshId((s, o, t) => this.forkTo(s, o, t), sourceId, owner, opts);
     }
     async forkTo(sourceId, owner, target) {
         for (let attempt = 0; attempt < 2; attempt++) {
@@ -275,7 +278,8 @@ export class TiDBSessionStore {
         try {
             await conn.beginTransaction();
             try {
-                await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation, fork_key) VALUES (?,?,?,?,?,?,?,?)", [target.id, forkOwner, now, now, forkLeafId, eventRows.length, mintSessionIncarnation(), target.key ?? null]);
+                await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation, fork_key, " +
+                    "placement_kind, placement_scope, placement_parent_session_id, placement_root_session_id, placement_handle, placed_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)", [target.id, forkOwner, now, now, forkLeafId, eventRows.length, mintSessionIncarnation(), target.key ?? null, ...placementInsertValues(target.placement, now)]);
             }
             catch (err) {
                 if (!isMysqlDupKeyError(err))

package/dist/prompt-screen.d.ts

@@ -6,16 +6,13 @@
  * 会被交付,只有屏判完才知道;本服务存 / 转目标的每张面(run 行预览、续跑输入、标题器取材)因此只能在交付之后写交付的那一份
  * (律的属主 = `run-acceptance.ts`)。屏**不在**的腿上没有「屏前」:交付的就是请求原文,提交那一刻就知道 —— 与没有屏这回事之前逐字同。
  *
- * ## 判据(一条)
- * 两座任一注册的 `uses.events` 覆盖屏听的任一站 ⇒ 有屏。`uses.events` 是注册**声明**的事件全集(名字或 `<前缀>.*`);引擎准入保证一张注册挂上的
- * handler 不越出它声明的事件(越出 = 准入拒),所以「声明里没有」⇒ 这条腿的总线上**一定**没有屏 —— 判据只会多判有屏(声明了、`register`
- * 时没挂),不会漏判。多判的代价是这条腿的那几张面等到交付才写(写的仍是交付的那一份),不是放行。
- *
- * ## 过渡(引擎包根今天没有导出这一判据)
- * 屏听哪两站、`<前缀>.*` 怎么覆盖,读的是引擎自己的判据(引擎的 `promptScreenHasHandlers` 问的就是这两站;前缀形的展开同引擎准入的读法)。
- * 引擎在包根导出「一组注册声明了 prompt 屏」的判据之后,{@link PROMPT_SCREEN_STATIONS} 与 {@link covers} 一起退役,本函数改调引擎那一只 —— 读口换、判据不变。
+ * ## 判据(一条,引擎的)
+ * 引擎的 `promptScreenDeclaredBy`:两座的注册并起来,任一张的 `uses.events`(名字或 `<前缀>.*`,按引擎准入的读法展开)选中屏听的任一站
+ * (引擎的 `PROMPT_SCREEN_STATIONS`)⇒ 有屏。引擎准入保证一张注册挂上的 handler 不越出它声明的事件(越出 = 准入拒),所以「声明里没有」⇒
+ * 这条腿的总线上**一定**没有屏 —— 判据只会多判有屏(声明了、`register` 时没挂),不会漏判。多判的代价是这条腿的那几张面等到交付才写
+ * (写的仍是交付的那一份),不是放行。站名表与前缀展开只住在引擎里:引擎给屏加一站,本服务同一拍就认。
  */
-import type { ModRegistration } from "@sema-agent/core";
+import { type ModRegistration } from "@sema-agent/core";
 /** 这条腿的两座(缺席的座 = 没有注册)里有没有一张注册声明了 prompt 屏。 */
 export declare function promptScreenDeclared(seats: ReadonlyArray<ReadonlyArray<Pick<ModRegistration, "uses">> | undefined>): boolean;
 //# sourceMappingURL=prompt-screen.d.ts.map

package/dist/prompt-screen.js

@@ -1,8 +1,5 @@
-const PROMPT_SCREEN_STATIONS = ["prompt.submit", "classic.UserPromptSubmit"];
-function covers(declared, station) {
-    return declared === station || (declared.endsWith(".*") && declared.length > 2 && station.startsWith(declared.slice(0, -1)));
-}
+import { promptScreenDeclaredBy } from "@sema-agent/core";
 export function promptScreenDeclared(seats) {
-    return seats.some((seat) => seat?.some((registration) => registration.uses.events.some((declared) => PROMPT_SCREEN_STATIONS.some((station) => covers(declared, station)))) === true);
+    return promptScreenDeclaredBy(seats.flatMap((seat) => seat ?? []));
 }
 //# sourceMappingURL=prompt-screen.js.map

package/dist/rules-consent.d.ts

@@ -1,5 +1,5 @@
 import { type DirectWritableRuleBehavior, type RemovalLiveness } from "./permission-rule-vocab.js";
-import { type RuleOwner, type ImportPreview, type ImportedSettingsLayer, type PersistedRule, type RuleBehavior, type RuleCandidate, type EffectivePermissionRule, type RemoveResult, type RuleWriteCommitted, type EditedRuleTextPrecheck, type RuleScope, type RuleOffer } from "@sema-agent/core";
+import { type RuleOwner, type ImportPreview, type ImportedSettingsLayer, type PersistedRule, type RuleBehavior, type RuleCandidate, type EffectivePermissionRule, type RemoveResult, type RuleRefusalCode, type RuleWriteCommitted, type EditedRuleTextPrecheck, type RuleScope, type RuleOffer } from "@sema-agent/core";
 import type { DurableRulePartitionProvider, PermissionRuleStoreProvider, RuleApprovalRecordStore } from "@sema-agent/core";
 import { type RuleImportTicket, type RuleTicketPurpose, type RuleTicketReclaimResult, type RuleTicketRedeemResult, type RuleTicketSnapshot } from "./plugins/permission-rule-store-sql.js";
 /**
@@ -192,31 +192,22 @@ export type LocalImportRefusalCode =
  | "not_importable";
 /** 兑付回执的**成员级终态**(闭集,机读;`detail` 是给人看的那一半)。两只 redeem 口(cc-import / local-import)同一张表。
  *
- *  🔴 **引擎的成员拒一律落 `indeterminate`,本仓不铸 `refused`**:core 的 `RedeemedBatchMember` 拒绝臂只带一个**自由文本**
- *  `reason`,而它装的东西两类都有 —— 裁定(引擎 7.62.0 对旧导入记录里从 `/` 写起的全局规则答 `unsupported.layer_root:`;
- *  批里的收紧没落、同批放行被扣下的 `withheld:`)与店侧成因(读不出店 / 写面抛 / OCC 用尽 —— 写面抛时那一条**可能已经落了**)。
- *  按串去猜「这是裁定还是瞬时」正是本仓明令禁止的自造判读,所以一律 `indeterminate`(安全方向:不谎报落了,也不担保没落),
- *  `detail` 原样带引擎的话 —— 人读得到出路(例:那句 `unsupported.layer_root:` 自己说「重新 prepare,这一条会披露在 skipped」)。
- *  `refused` 留在词表里是给**带类型的**判别位到货那一天(引擎给拒绝臂一个机读的「裁定 / 瞬时」位之后,裁定那一类落 `refused`):
- *  它进了**落盘回执的边界 schema**(`ImportOutcomeSchema`;`redeemed_outcome` 列回读同一张词表),滚动升级窗里先升的进程写下的
- *  `refused`,后升的进程读得回。⚠️ 预览面**不用**这个词:那一面的拒绝形是 `admitted:false + LocalImportRefusalCode`
- *  ({@link LocalImportPreviewMember}),两面词表**不同**。 */
+ *  🔴 **引擎拒的成员,结局只读引擎的两词 `committed`**(core 7.63.0 [ref],`RedeemedBatchMember` 拒臂必填):`no` ⇒ `refused`
+ *  (引擎确知这一条没落 —— 裁定,如旧导入记录里从 `/` 写起的全局规则的 `unsupported.layer_root`;同批放行被扣下的 `withheld`)、
+ *  `unknown` ⇒ `indeterminate`(写面抛 / 读回读不出 —— 那一条**可能已经落了**)。本仓不按串判,不另写第二份判据。
+ *  它进了**落盘回执的边界 schema**(`ImportOutcomeSchema`;`redeemed_outcome` 列回读同一张词表)。⚠️ 预览面**不用**这个词表:那一面的拒绝形是
+ *  `admitted:false + LocalImportRefusalCode`({@link LocalImportPreviewMember}),两面词表**不同**。 */
 export type ImportMemberOutcome = 
 /** 这一次真的写进店里了。 */
 "persisted"
 /** 等价规则**已经在店**(引擎的 `deduped`)—— 同意早就生效,这次什么都不用做。 */
  | "no-op"
-/** 这条被拒了、确知没落(留给带类型判别位的词位,本版不铸 —— 见上)。 */
+/** 引擎拒了这一条,并答 `committed: "no"` —— 确知没落。重来同一条拒因(`reason`)会得同一个答,出路在 `detail`(引擎原话)。 */
  | "refused"
-/** **不知道落没落**:引擎在这一条上答了拒,而拒因只有自由文本。如实编,禁猜(猜"成了"会谎报一次没发生的授权,
- *  猜"没成"会让人以为可以盲目重来,而重来可能撞上一条其实已经存在的规则 —— 对账读 `GET /v1/rules`,重来走一次新的导入,幂等)。 */
+/** 引擎拒了这一条,并答 `committed: "unknown"` —— **不知道落没落**。如实编,禁猜。这一词**不进落定的回执**(落定律:任一成员
+ *  结局不知 ⇒ 不落定、503 同票重走,见 {@link unsettledDetailOf});词表留着它,是因为 7.145.x 及更早落定的票行(`redeemed_outcome`)
+ *  里有它,回放读那份存量。 */
  | "indeterminate";
-/** `indeterminate` 的成因(闭集,一词)。
- *  「兑付走本身没走完」**不是**一个成员终态:那一形没有完整成员表,兑付不落定(放回认领、503 `state.rule_import_retry`,
- *  同一张票重走交出完整表)—— 所以没有第二个词。 */
-export type ImportIndeterminateCode = 
-/** 引擎在这一条上答了拒(`RedeemedBatchMember` 的 `refused` 臂),而拒因只有自由文本 ⇒ 落不了裁定,如实说"不知道"。 */
-"store_refused";
 /** prepare 面的一行。判别式联合:被收下的行**没有**拒因字段可读,被拒的行**必然**带拒因 ——
  *  「admitted 却带 reason」这种矛盾态在类型上不可表达。
  *  收下的**收紧**(deny / ask)在 prepare 当场经直写接缝落店,行带它的结局 `outcome`(`persisted` = 这次写了 / `no-op` = 等价规则已在店);
@@ -236,24 +227,26 @@ export type LocalImportPreviewMember = {
 };
 /** 一条收紧在 prepare 当场落店的结局(与兑付回执的 `persisted` / `no-op` 同词同义;直写接缝 `addPersistedRule` 的 `added` / `no-op`)。 */
 export type LocalImportTighteningOutcome = "persisted" | "no-op";
-/** 兑付回执的一行(两只 redeem 口同形;唯一铸点 {@link buildImportOutcomeMembers})。 */
+/** 兑付回执的一行(两只 redeem 口同形;唯一铸点 {@link buildImportOutcomeMembers})。`reason` / `detail` 在场 ⇔ 引擎拒了这一条
+ *  (`refused` / `indeterminate`):`reason` = 引擎的闭集拒因码(`RuleRefusalCode`,core 属主,逐字),`detail` = 引擎给人看的那句话。 */
 export interface ImportOutcomeMember {
     key: ImportRuleKey;
     outcome: ImportMemberOutcome;
-    reason?: ImportIndeterminateCode;
+    reason?: RuleRefusalCode;
     detail?: string;
 }
 /**
  * 一次兑付的回执整只 —— **两只 redeem 口同一张**(cc-import / local-import 的 200 体都是 `{ members, rev }`,路由同一个铸点),
  * local-import 另把它**逐字**写进票行 `redeemed_outcome`(回放同源:回放答的就是它)。
  *
- * 🔴 **落定律(一条,两口同读)**:兑付走完、拿到引擎的**完整成员表** ⇒ 这次兑付落定,回执逐成员交出(引擎的成员拒落
- * `indeterminate`,见 {@link ImportMemberOutcome}),票不放回、不答 503:cc-import 一次性用掉、答 200 回执;local-import 把回执
+ * 🔴 **落定律(一条,两口同读)**:兑付走完、拿到引擎的完整成员表、**且每个成员的结局都确定**(`persisted` / `no-op` / 引擎答
+ * `committed: "no"` 的 `refused`)⇒ 这次兑付落定,回执逐成员交出,票不放回、不答 503:cc-import 一次性用掉、答 200 回执;local-import 把回执
  * 落进票行(SETTLED)后答 200 —— 落定这一跳答不成(落定写抛 / 认领被租约接管而新持有者还没落定)⇒ 照旧答 409
  * `conflict.rule_import_in_flight`,同票再来读到的是权威的那一份回执(那一跳不改成员结局,只决定哪一份是权威)。**没有**完整
- * 成员表(引擎在走之前整批拒 / 走到一半抛 / confirm 输给并发写者 / 店在走之前抛)⇒ 不落定:放回认领、503
+ * 成员表(引擎在走之前整批拒 / confirm 输给并发写者 / 店在走之前抛 / 循环里仍抛出来的异常),或任一成员结局**不知**(引擎答
+ * `committed: "unknown"`:规则店的写抛 / 读回读不出,引擎 7.64.0 起还有成员循环里审批记录店的记 dot CAS / dot 分配失败)⇒ 不落定:放回认领、503
  * `state.rule_import_retry`,同一张票重来就是重走一遍 —— 兑付按引擎的设计幂等(记录里的 dot 台账),重走交出完整表,
- * 被打断的那一走已落的成员读 `no-op`。成员拒**不**按票自动重试:一条永久被拒的成员(旧记录里的 `unsupported.layer_root`)
+ * 被打断的那一走已落的成员读 `no-op`。确知的成员拒**不**按票自动重试:一条永久被拒的成员(旧记录里的 `unsupported.layer_root`)
  * 若走重试臂,客户端会 503 到票过期、临期放不回 ⇒ 404,已落成员不撤、被拒成员永不落 —— 7.144.0 及更早 cc-import 口就是这一形。
  */
 export interface ImportOutcome {
@@ -346,12 +339,12 @@ export type RuleImportPrepared = {
  *  `state.rule_import_retry`;`state-unreadable` ⇒ 503 `state.rule_ticket_unreadable`。分类保留只为服务端日志/诊断与
  *  上述三分支的判据。 */
 export type RuleImportRedeemed = 
-/** 兑付走完、拿到完整成员表 ⇒ 落定(成员里有引擎拒的也在这一臂,那几行 `indeterminate`)。 */
+/** 兑付走完、拿到完整成员表且每个成员结局确定 ⇒ 落定(引擎确知没落的成员也在这一臂,那几行 `refused`)。 */
 {
     ok: true;
     outcome: ImportOutcome;
 }
-/** `retryable` = 这次失败**没有裁定任何事**、也**没有完整成员表**(store 抛错 / CAS 冲突 / 引擎走之前整批拒 / 走到一半抛),
+/** `retryable` = 这次兑付**没有落定**(store 抛错 / CAS 冲突 / 引擎走之前整批拒 / 循环里仍抛出来的异常 / 某个成员结局不知),
  *  认领已放回,属主原样重试即重走。
  *  它与裁定性拒绝(载荷被改写、记录不存在)分家是承重的:把两者塌成一格,一次数据库抖动就会被
  *  客户端读成「这张票永远不能用了」。⚠️ wire 面**不再**折 404:`retryable === true` ⇒ 503