@sema-agent/server 7.139.0 → 7.140.0

package/dist/plugins/tool-result-store-sql.js

@@ -24,7 +24,7 @@ export async function ensureSchema(pool) {
     await ensureIndexes((t, p) => pool.query(t, p), "pg", TOOL_RESULT_INDEXES);
 }
 export async function assertToolResultProvenanceSchema(query, dialect) {
-    const widthRow = await query(dialect === "tidb"
+    const widthRow = await query(dialect === "mysql"
         ? "SELECT CHARACTER_MAXIMUM_LENGTH AS len FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'tool_result' AND column_name = 'ref'"
         : "SELECT character_maximum_length AS len FROM information_schema.columns WHERE table_schema = current_schema() AND table_name = 'tool_result' AND column_name = 'ref'").catch(() => ({ rows: [] }));
     const width = Number(widthRow.rows[0]?.len ?? NaN);
@@ -62,8 +62,8 @@ export class SqlToolResultStore {
         this.db = db;
         this.retention = opts.retention ?? UNMANAGED_RETENTION;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     isUnsafeRef(ref) {
         try {

package/dist/plugins/user-input-ledger-sql.js

@@ -69,8 +69,8 @@ export class SqlUserInputLedgerStore {
     constructor(db) {
         this.db = db;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     async accept(a) {
         try {

package/dist/plugins/workflow-journal-store-sql.js

@@ -15,8 +15,8 @@ export class SqlWorkflowJournalStore {
         this.db = db;
         this.resumeClaimTtlMs = opts?.resumeClaimTtlMs ?? DEFAULT_RESUME_CLAIM_TTL_MS;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     async append(runId, scope, entry) {
         assertJournalEntryFits(entry);
@@ -35,7 +35,7 @@ export class SqlWorkflowJournalStore {
         }
     }
     async load(runId, scope) {
-        const { rows } = await this.db.query(this.q(`SELECT call_key, ${jsonColumnText("tidb", "result")} FROM workflow_journal JOIN workflow_journal_owner USING (run_id, incarnation) WHERE run_id = ? AND scope = ? ORDER BY ordinal ASC`, `SELECT call_key, ${jsonColumnText("pg", "result")} FROM workflow_journal JOIN workflow_journal_owner USING (run_id, incarnation) WHERE run_id = $1 AND scope = $2 ORDER BY ordinal ASC`), [runId, scope]);
+        const { rows } = await this.db.query(this.q(`SELECT call_key, ${jsonColumnText("mysql", "result")} FROM workflow_journal JOIN workflow_journal_owner USING (run_id, incarnation) WHERE run_id = ? AND scope = ? ORDER BY ordinal ASC`, `SELECT call_key, ${jsonColumnText("pg", "result")} FROM workflow_journal JOIN workflow_journal_owner USING (run_id, incarnation) WHERE run_id = $1 AND scope = $2 ORDER BY ordinal ASC`), [runId, scope]);
         return rows.map((r) => {
             const callKey = String(r.call_key);
             return journalEntryOfCell(runId, callKey, r.result, `workflow_journal.result for run ${runId} entry ${callKey}`);
@@ -69,10 +69,10 @@ export class SqlWorkflowJournalStore {
         return row !== undefined && row.ordinal === ordinal && row.resultJson !== null ? row.resultJson : undefined;
     }
     async readRows(runId, scope, from, limit, inlineBytes) {
-        const params = this.db.dialect === "tidb"
+        const params = this.db.dialect === "mysql"
             ? [inlineBytes, runId, scope, from, limit]
             : [runId, scope, inlineBytes, from, limit];
-        const { rows } = await this.db.query(this.q(`SELECT ordinal, call_key, CASE WHEN LENGTH(result) > ? THEN NULL ELSE ${jsonColumnTextExpr("tidb", "result")} END AS result_json, LENGTH(result) AS result_bytes FROM workflow_journal JOIN workflow_journal_owner USING (run_id, incarnation) WHERE run_id = ? AND scope = ? AND ordinal >= ? ORDER BY ordinal ASC LIMIT ?`, `SELECT ordinal, call_key, CASE WHEN OCTET_LENGTH(result) > $3 THEN NULL ELSE ${jsonColumnTextExpr("pg", "result")} END AS result_json, OCTET_LENGTH(result) AS result_bytes FROM workflow_journal JOIN workflow_journal_owner USING (run_id, incarnation) WHERE run_id = $1 AND scope = $2 AND ordinal >= $4 ORDER BY ordinal ASC LIMIT $5`), params);
+        const { rows } = await this.db.query(this.q(`SELECT ordinal, call_key, CASE WHEN LENGTH(result) > ? THEN NULL ELSE ${jsonColumnTextExpr("mysql", "result")} END AS result_json, LENGTH(result) AS result_bytes FROM workflow_journal JOIN workflow_journal_owner USING (run_id, incarnation) WHERE run_id = ? AND scope = ? AND ordinal >= ? ORDER BY ordinal ASC LIMIT ?`, `SELECT ordinal, call_key, CASE WHEN OCTET_LENGTH(result) > $3 THEN NULL ELSE ${jsonColumnTextExpr("pg", "result")} END AS result_json, OCTET_LENGTH(result) AS result_bytes FROM workflow_journal JOIN workflow_journal_owner USING (run_id, incarnation) WHERE run_id = $1 AND scope = $2 AND ordinal >= $4 ORDER BY ordinal ASC LIMIT $5`), params);
         return rows.map((r) => ({ ordinal: Number(r.ordinal), callKey: String(r.call_key), resultJson: r.result_json === null ? null : String(r.result_json), resultBytes: Number(r.result_bytes) }));
     }
     async deleteByRun(runId) {

package/dist/plugins/workflow-run-store-sql.js

@@ -57,8 +57,8 @@ export class SqlWorkflowRunStore {
         this.db = db;
         this.onWarn = onWarn;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     async put(id, run) {
         const stored = { ...withRedactedError(run), id, rev: run.rev ?? 0 };
@@ -73,7 +73,7 @@ export class SqlWorkflowRunStore {
         }
     }
     async get(id) {
-        const { rows } = await this.db.query(this.q(`SELECT ${jsonColumnText("tidb", "run")}, rev FROM workflow_run WHERE id = ?`, `SELECT ${jsonColumnText("pg", "run")}, rev FROM workflow_run WHERE id = $1`), [id]);
+        const { rows } = await this.db.query(this.q(`SELECT ${jsonColumnText("mysql", "run")}, rev FROM workflow_run WHERE id = ?`, `SELECT ${jsonColumnText("pg", "run")}, rev FROM workflow_run WHERE id = $1`), [id]);
         const r = rows[0];
         if (!r)
             return null;
@@ -100,7 +100,7 @@ export class SqlWorkflowRunStore {
         const params = [scope];
         let where;
         let limit = "";
-        if (this.db.dialect === "tidb") {
+        if (this.db.dialect === "mysql") {
             where = "scope = ?";
             if (opts?.status !== undefined) {
                 where += " AND status = ?";
@@ -160,9 +160,9 @@ export class SqlWorkflowRunStore {
         }
         if (doomed.length === 0)
             return 0;
-        const res = await this.db.query(this.q(`DELETE FROM workflow_run WHERE scope = ? AND id IN (${doomed.map(() => "?").join(",")})`, "DELETE FROM workflow_run WHERE scope = $1 AND id = ANY($2::text[])"), this.db.dialect === "tidb" ? [scope, ...doomed] : [scope, doomed]);
-        await this.db.query(this.q(`DELETE FROM workflow_agent_session WHERE scope = ? AND run_id IN (${doomed.map(() => "?").join(",")})`, "DELETE FROM workflow_agent_session WHERE scope = $1 AND run_id = ANY($2::text[])"), this.db.dialect === "tidb" ? [scope, ...doomed] : [scope, doomed]);
-        await this.db.query(this.q(`DELETE FROM workflow_park_decision WHERE run_id IN (${doomed.map(() => "?").join(",")})`, "DELETE FROM workflow_park_decision WHERE run_id = ANY($1::text[])"), this.db.dialect === "tidb" ? [...doomed] : [doomed]);
+        const res = await this.db.query(this.q(`DELETE FROM workflow_run WHERE scope = ? AND id IN (${doomed.map(() => "?").join(",")})`, "DELETE FROM workflow_run WHERE scope = $1 AND id = ANY($2::text[])"), this.db.dialect === "mysql" ? [scope, ...doomed] : [scope, doomed]);
+        await this.db.query(this.q(`DELETE FROM workflow_agent_session WHERE scope = ? AND run_id IN (${doomed.map(() => "?").join(",")})`, "DELETE FROM workflow_agent_session WHERE scope = $1 AND run_id = ANY($2::text[])"), this.db.dialect === "mysql" ? [scope, ...doomed] : [scope, doomed]);
+        await this.db.query(this.q(`DELETE FROM workflow_park_decision WHERE run_id IN (${doomed.map(() => "?").join(",")})`, "DELETE FROM workflow_park_decision WHERE run_id = ANY($1::text[])"), this.db.dialect === "mysql" ? [...doomed] : [doomed]);
         return res.affected;
     }
 }
@@ -175,8 +175,8 @@ export class SqlWorkflowCompletionInbox {
         this.db = db;
         this.onWarn = onWarn;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     async sweepFences(now) {
         await this.db.query(this.q("DELETE FROM workflow_inbox_fence WHERE until_ms < ?", "DELETE FROM workflow_inbox_fence WHERE until_ms < $1"), [now]);
@@ -213,7 +213,7 @@ export class SqlWorkflowCompletionInbox {
         }
         const over = await this.db.query(this.q("SELECT seq, run_id FROM workflow_completion_inbox WHERE session_id = ? ORDER BY seq DESC LIMIT 100000 OFFSET ?", "SELECT seq, run_id FROM workflow_completion_inbox WHERE session_id = $1 ORDER BY seq DESC OFFSET $2"), [entry.sessionId, MAX_PENDING_PER_SESSION]);
         if (over.rows.length > 0) {
-            await this.db.query(this.q(`DELETE FROM workflow_completion_inbox WHERE session_id = ? AND seq IN (${over.rows.map(() => "?").join(",")})`, "DELETE FROM workflow_completion_inbox WHERE session_id = $1 AND seq = ANY($2::bigint[])"), this.db.dialect === "tidb" ? [entry.sessionId, ...over.rows.map((r) => r.seq)] : [entry.sessionId, over.rows.map((r) => r.seq)]);
+            await this.db.query(this.q(`DELETE FROM workflow_completion_inbox WHERE session_id = ? AND seq IN (${over.rows.map(() => "?").join(",")})`, "DELETE FROM workflow_completion_inbox WHERE session_id = $1 AND seq = ANY($2::bigint[])"), this.db.dialect === "mysql" ? [entry.sessionId, ...over.rows.map((r) => r.seq)] : [entry.sessionId, over.rows.map((r) => r.seq)]);
             for (const r of over.rows)
                 this.onWarn?.("workflow_completion_inbox_overflow", { sessionId: entry.sessionId, droppedRunId: String(r.run_id) });
         }
@@ -243,7 +243,7 @@ export class SqlWorkflowCompletionInbox {
         await this.sweepFences(now);
         await this.db.query(this.q("INSERT INTO workflow_inbox_fence (session_id, kind, run_id, owner, owner_known, until_ms) VALUES (?,?,?,?,?,?) " +
             "ON DUPLICATE KEY UPDATE owner = VALUES(owner), owner_known = VALUES(owner_known), until_ms = VALUES(until_ms)", "INSERT INTO workflow_inbox_fence (session_id, kind, run_id, owner, owner_known, until_ms) VALUES ($1,$2,'',$3,$4,$5) " +
-            "ON CONFLICT (session_id, kind, run_id) DO UPDATE SET owner = EXCLUDED.owner, owner_known = EXCLUDED.owner_known, until_ms = EXCLUDED.until_ms"), this.db.dialect === "tidb"
+            "ON CONFLICT (session_id, kind, run_id) DO UPDATE SET owner = EXCLUDED.owner, owner_known = EXCLUDED.owner_known, until_ms = EXCLUDED.until_ms"), this.db.dialect === "mysql"
             ? [sessionId, KIND_PURGE, "", purgedOwner ?? null, purgedOwner !== undefined ? 1 : 0, now + PURGE_FENCE_MS]
             : [sessionId, KIND_PURGE, purgedOwner ?? null, purgedOwner !== undefined ? 1 : 0, now + PURGE_FENCE_MS]);
         await this.db.query(this.q("DELETE FROM workflow_completion_inbox WHERE session_id = ?", "DELETE FROM workflow_completion_inbox WHERE session_id = $1"), [sessionId]);
@@ -263,8 +263,8 @@ export class SqlWorkflowNotifyJournalStore {
     constructor(db) {
         this.db = db;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     async record(input) {
         await this.db.query(this.q("INSERT IGNORE INTO workflow_notify_journal (run_id, scope, acked, source_task_id, principal, created_at_ms) VALUES (?,?,0,?,?,?)", "INSERT INTO workflow_notify_journal (run_id, scope, acked, source_task_id, principal, created_at_ms) VALUES ($1,$2,0,$3,$4,$5) ON CONFLICT (run_id) DO NOTHING"), [input.runId, input.scope, input.sourceTaskId ?? null, input.principal ?? null, input.createdAt]);
@@ -308,8 +308,8 @@ export class SqlWorkflowAgentSessionIndex {
     constructor(db) {
         this.db = db;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     async ensurePointers(_runId, rows) {
         for (const r of rows) {
@@ -335,8 +335,8 @@ export class SqlWorkflowParkDecisionStore {
     constructor(claims) {
         this.claims = claims;
     }
-    q(tidb, pg) {
-        return this.claims.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.claims.db.dialect === "mysql" ? mysql : pg;
     }
     async record(d) {
         const fenced = await this.claims.whileHoldingClaim(d.hostSessionId, d.deliveredTaskId, async (tx) => {
@@ -347,12 +347,12 @@ export class SqlWorkflowParkDecisionStore {
         return fenced.held;
     }
     async get(token) {
-        const { rows } = await this.claims.db.query(this.q(`SELECT token, run_id, host_session_id, ${jsonColumnText("tidb", "outcome")}, fingerprint, delivered_task_id, accepted_at_ms FROM workflow_park_decision WHERE token = ?`, `SELECT token, run_id, host_session_id, ${jsonColumnText("pg", "outcome")}, fingerprint, delivered_task_id, accepted_at_ms FROM workflow_park_decision WHERE token = $1`), [token]);
+        const { rows } = await this.claims.db.query(this.q(`SELECT token, run_id, host_session_id, ${jsonColumnText("mysql", "outcome")}, fingerprint, delivered_task_id, accepted_at_ms FROM workflow_park_decision WHERE token = ?`, `SELECT token, run_id, host_session_id, ${jsonColumnText("pg", "outcome")}, fingerprint, delivered_task_id, accepted_at_ms FROM workflow_park_decision WHERE token = $1`), [token]);
         const r = rows[0];
         return r ? rowToParkDecision(r) : null;
     }
     async listByHostSession(hostSessionId) {
-        const { rows } = await this.claims.db.query(this.q(`SELECT token, run_id, host_session_id, ${jsonColumnText("tidb", "outcome")}, fingerprint, delivered_task_id, accepted_at_ms FROM workflow_park_decision WHERE host_session_id = ?`, `SELECT token, run_id, host_session_id, ${jsonColumnText("pg", "outcome")}, fingerprint, delivered_task_id, accepted_at_ms FROM workflow_park_decision WHERE host_session_id = $1`), [hostSessionId]);
+        const { rows } = await this.claims.db.query(this.q(`SELECT token, run_id, host_session_id, ${jsonColumnText("mysql", "outcome")}, fingerprint, delivered_task_id, accepted_at_ms FROM workflow_park_decision WHERE host_session_id = ?`, `SELECT token, run_id, host_session_id, ${jsonColumnText("pg", "outcome")}, fingerprint, delivered_task_id, accepted_at_ms FROM workflow_park_decision WHERE host_session_id = $1`), [hostSessionId]);
         return rows.map(rowToParkDecision);
     }
 }

package/dist/plugins/write-behind-counter.d.ts

@@ -34,6 +34,7 @@
 import type { Pool as MySqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
 import { type AlignedWindow } from "../observability/cost-quota.js";
+import type { SqlDialect } from "./sql-driver.js";
 export interface CounterTable {
     /** Table name; must have columns (<keyCol>, window_bucket BIGINT, <valCol>, updated_at). */
     table: string;
@@ -56,7 +57,6 @@ export type CounterDegradeHook = (info: CounterDegradeInfo) => void;
  *  flush round forever; the stalled watchdog can then only report, not recover). The rejection lands in
  *  the existing flush/refresh catch → the S9 streak telemetry counts it; the round ENDS and retries. */
 export declare const DEFAULT_COUNTER_QUERY_TIMEOUT_MS = 30000;
-type CounterDialect = "tidb" | "pg";
 /** Dual-dialect write-behind aggregating counter. See the file header for the dialect-delta ledger. */
 export declare class SqlWriteBehindCounter {
     private readonly dialect;
@@ -73,7 +73,7 @@ export declare class SqlWriteBehindCounter {
     private flushing;
     private flushStartedAt;
     private failStreak;
-    constructor(dialect: CounterDialect, pool: MySqlPool | PgPool, t: CounterTable, 
+    constructor(dialect: SqlDialect, pool: MySqlPool | PgPool, t: CounterTable, 
     /** 🔴 不再 `readonly`([ref]):`costQuotaWindowSec` 热更新经 {@link setWindowMs} 换代,语义见那里。 */
     windowMs: number, now?: () => number, onDegraded?: CounterDegradeHook | undefined, // S9: observability tap — never affects counting
     queryTimeoutMs?: number);
@@ -135,5 +135,4 @@ export declare class WriteBehindCounter extends SqlWriteBehindCounter {
 export declare class PgWriteBehindCounter extends SqlWriteBehindCounter {
     constructor(pool: PgPool, t: CounterTable, windowMs: number, now?: () => number, onDegraded?: CounterDegradeHook, queryTimeoutMs?: number);
 }
-export {};
 //# sourceMappingURL=write-behind-counter.d.ts.map

package/dist/plugins/write-behind-counter.js

@@ -25,7 +25,7 @@ export class SqlWriteBehindCounter {
         this.queryTimeoutMs = queryTimeoutMs;
     }
     async exec(sql, params) {
-        if (this.dialect === "tidb") {
+        if (this.dialect === "mysql") {
             const [r] = (await this.pool.query({ sql, timeout: this.queryTimeoutMs }, params));
             if (Array.isArray(r))
                 return { rows: r, affected: 0 };
@@ -92,7 +92,7 @@ export class SqlWriteBehindCounter {
     }
     async flushOnce() {
         const { table, keyCol, valCol } = this.t;
-        const sql = this.dialect === "tidb"
+        const sql = this.dialect === "mysql"
             ? `INSERT INTO ${table} (${keyCol}, window_bucket, ${valCol}, updated_at) VALUES (?,?,?,?) ` +
                 `ON DUPLICATE KEY UPDATE ${valCol} = ${valCol} + VALUES(${valCol}), updated_at = VALUES(updated_at)`
             : `INSERT INTO ${table} (${keyCol}, window_bucket, ${valCol}, updated_at) VALUES ($1,$2,$3,$4) ` +
@@ -129,7 +129,7 @@ export class SqlWriteBehindCounter {
         const { table, keyCol, valCol } = this.t;
         const b = this.bucket();
         try {
-            const { rows } = await this.exec(this.dialect === "tidb"
+            const { rows } = await this.exec(this.dialect === "mysql"
                 ? `SELECT ${keyCol}, ${valCol} FROM ${table} WHERE window_bucket = ?`
                 : `SELECT ${keyCol}, ${valCol} FROM ${table} WHERE window_bucket = $1`, [b]);
             const next = new Map();
@@ -145,7 +145,7 @@ export class SqlWriteBehindCounter {
     }
     async reap() {
         try {
-            const { affected } = await this.exec(this.dialect === "tidb"
+            const { affected } = await this.exec(this.dialect === "mysql"
                 ? `DELETE FROM ${this.t.table} WHERE window_bucket < ?`
                 : `DELETE FROM ${this.t.table} WHERE window_bucket < $1`, [this.bucket()]);
             this.bump("reap", false);
@@ -175,7 +175,7 @@ export class SqlWriteBehindCounter {
 }
 export class WriteBehindCounter extends SqlWriteBehindCounter {
     constructor(pool, t, windowMs, now, onDegraded, queryTimeoutMs) {
-        super("tidb", pool, t, windowMs, now, onDegraded, queryTimeoutMs);
+        super("mysql", pool, t, windowMs, now, onDegraded, queryTimeoutMs);
     }
 }
 export class PgWriteBehindCounter extends SqlWriteBehindCounter {

package/dist/resource-suspend.d.ts

@@ -5,24 +5,26 @@
  * task opts in, a budget/turns/walltime limit OR a scheduler preempt durably SUSPENDS the task (resumable via
  * `POST /v1/assistant/tasks/:id/resume`) instead of FAILING; absent ⇒ a limit still FAILS.
  *
- * 🔴 EXCLUDE verify/cascade tasks. Core runs their implementation via `runWithVerification`/`runCascade`, which
- * map an inner durable suspend to a FAILED result (`errorCode: "unexpected.suspended"`,内层 status
- * "needs_review" 时铸 `"unexpected.needs_review"` —— 真源是 core `agents/suspend-guard.js` 的
- * `mapNestedSuspend`;`suspended.*` 三码是 bg 子代/委派报告面的词,不落在这条 TaskResult 腿上). The service would then
- * `setTerminal(failed)` while core had already minted a pending `resource_limit` checkpoint + suspended the
- * remote VM — ORPHANING both (the run row is terminal, so nothing resumes them). So a resource-limit hit on a
- * verify/cascade task must FAIL CLEANLY (no suspend), exactly as before the flag. This exclusion is the SAME
- * boundary the `preemptSignal` wiring enforces in runs.ts (stream-path only), so eligibility and the signal stay
- * aligned. (Cross review wtyc7ist3 HIGH finding: without this, enabling RESOURCE_SUSPEND leaks a suspended
- * VM + checkpoint on every verify/cascade task that hits a resource limit.)
+ * 🔴 EXCLUDE cascade tasks. Core runs a cascade through `runCascade`, which maps a rung's durable suspend to a FAILED
+ * result carrying the pause (`errorCode: "unexpected.suspended"`, 内层 status "needs_review" 时铸 `"unexpected.needs_review"`,
+ * 停驻因由在 `terminal.nestedPause` —— 真源是 core `agents/suspend-guard.js` 的 `mapNestedSuspend`;`suspended.*` 三码是 bg
+ * 子代/委派报告面的词,不落在这条 TaskResult 腿上). A rung's pause lands on the rung's own engine-minted session, which the
+ * host-boundary judge (`atHostBoundary`, src/terminal.ts) leaves terminal: the service would `setTerminal(failed)` while core
+ * had already minted a pending `resource_limit` checkpoint + suspended the remote VM — ORPHANING both (the run row is
+ * terminal, so nothing resumes them). A resource-limit hit on a cascade task must FAIL CLEANLY (no suspend).
+ * (Cross review wtyc7ist3 HIGH finding: without this, enabling RESOURCE_SUSPEND leaks a suspended VM + checkpoint on every
+ * cascade task that hits a resource limit.) The arm is the judge's session cell seen from the opt-in side: the day the engine
+ * lets a rung's pause land on a session the host's resume chain reaches (core [ref]), the judge's answer flips and this arm goes.
+ * Every other task — a verify task included — opts in alike. A verify task's implementation leg and fix rounds run on the
+ * run's own session, so the judge lifts their pause into a park of the run row (resumable through
+ * `POST /v1/assistant/tasks/:id/resume`); the verifier's own leg is built by the engine without an opt-in, so a limit there
+ * still fails that leg.
  */
 export declare function resourceSuspendOptIn(opts: {
     /** `RESOURCE_SUSPEND=true` (the worker-level switch). */
     enabled: boolean;
     /** `RESOURCE_SUSPEND_TTL_SEC` — 0 ⇒ core default (30d) by omitting `ttlMs`. */
     ttlSec: number;
-    /** This task requested the developer-mode verify gate (`body.verify === true`). */
-    isVerify: boolean;
     /** This task requested the cascade ladder (`body.cascade === true`). */
     isCascade: boolean;
     /** Multi-tenant isolation key — the SAME key durableApproval uses (the principal; "_" when auth is off). */

package/dist/resource-suspend.js

@@ -1,5 +1,5 @@
 export function resourceSuspendOptIn(opts) {
-    if (!opts.enabled || opts.isVerify || opts.isCascade)
+    if (!opts.enabled || opts.isCascade)
         return undefined;
     return {
         scope: opts.scope,

package/dist/resource-window.d.ts

@@ -9,7 +9,7 @@
  * 【两半各自的真源(刻意不自建第三本账)】
  *  · **上限半**:本模块的进程内登记册 —— 记的是**这条 run 真正铸给 core 的那只 `resourceSuspend`**
  *    (装配点 `boot/resolve-spec.ts` 的 `resourceSuspendOptIn`),不是读时现取 env。差别是承重的:
- *    ① verify/cascade 腿被 `resourceSuspendOptIn` **整只排除**(opt-in 不成立)⇒ 登记册里没有它 ⇒
+ *    ① cascade 腿被 `resourceSuspendOptIn` **整只排除**(opt-in 不成立)⇒ 登记册里没有它 ⇒
  *       整键缺席,绝不显示一个没人执行的天花板;② 滚动改 env 之后,已在跑的 run 报的仍是它自己那份。
  *  · **已耗半**:run 自己的 durable 账本行 `model_usage`(`trace/project.ts` 的 `aggregateModelUsage`)——
  *    与 `TaskStats.modelUsage` 回声**同一份账**,append-only、跨 slice、跨进程(每条腿只追加自己的
@@ -21,7 +21,8 @@
  * core 的 `spentTokens` 轴 = 每片 `TaskStats.tokens`(= Σ 每次调用 `usage.totalTokens`,**不含**委派子代,
  * 子代在 `stats.nested`),而 `model_usage` 行正是同一批 `brain.call` 的逐 turn delta、同样只收顶层 run。
  * 已知差:① **滞后至多一个 turn**(delta 在 turn 边界 drain,进行中的那一 turn 还没入账);② 账本行
- * 写失败(F 类)会少计。⇒ 本投影是**分诊/预警**读面,**不是**任何门/CAS/resume 判定的输入。
+ * 写失败(F 类)会少计;③ 只回结果的组合腿(verify)没有逐 turn 落账的流,`model_usage` 行只在停驻 / 终局那一拍写 ⇒
+ * running 期读到的是上一次停驻时的量,滞后**一整片**(钉:`test/resource-suspend.test.ts` 的 🚧 格)。⇒ 本投影是**分诊/预警**读面,**不是**任何门/CAS/resume 判定的输入。
  *
  * 【登记册的语义边界(与 `turn-activity.ts` 的 `msSinceLastActivity` 逐字同族)】
  *  · **同副本 best-effort**:只活在本进程。跨副本 poll(run 跑在别的副本)或本副本重启后 ⇒ 读不到 ⇒
@@ -34,7 +35,7 @@
  * 【已声明的代价:每次 poll 一次全量账本读(codex 交叉复审 R2-[medium],如实登记、本批不修)】
  * {@link buildCrossSliceUsage} 要对**全部** `model_usage` 行求和 ⇒ 调用点(`routes/runs.ts` 的 poll)在
  * 窗已登记时每拍读一次 `getEvents(taskId, 0)`,工作量随「轮询次数 × 已积累事件数」增长。三条限幅是**结构性**
- * 的,不是「应该很少见」:① **只有登记过窗的 run 才读**(没开三旋钮的部署、以及 verify/cascade 腿,一次都不读);
+ * 的,不是「应该很少见」:① **只有登记过窗的 run 才读**(没开三旋钮的部署、以及 cascade 腿,一次都不读);
  * ② 只在 `running` 且非 stale 时读;③ 同一条路上早已存在同形读(终局 + 配了 infra 价目表时的 `needCost` 臂,
  * 同样是 `getEvents(taskId, 0)`)—— 本批加的是**跑动期**这一档,不是新病种。
  * 🔴 真正的收口在**存储面**(不在本模块):给 run store 加一条「累计用量 + resource_limit park 计数」的

package/dist/run-local.js

@@ -25,13 +25,13 @@ import { acquireLocalBackendWithWait } from "./plugins/store-lock-wait.js";
 import { configLocalRoot, createConfigProvider } from "./config-provider.js";
 import { CONFIG_DOMAIN_INVALID_NOTE, buildCandidateRejectedFields, judgeConfigCandidate } from "./web-admin-client/candidate-gate.js";
 import { buildUnreadConfigFileFields, buildUnreadConfigKeyFields } from "./web-admin-client/read-warnings.js";
-import { composeExecutionLane, settleHostLaneShell } from "./boot/execution-lane.js";
+import { composeExecutionLane, settleHostLaneShell, warnReadDenyFloorUnkept } from "./boot/execution-lane.js";
 import { judgeConsolidationValve } from "./boot/memory-consolidation.js";
 import { logConfigDirMigration, migrateLocalConfigDirectory } from "./config-d-migration.js";
 import { assertLocalConfigDirTrusted, ConfigDirUntrustedError } from "./config-dir-trust.js";
 import { applyEffective, applyCenterReadFace, applySkillsManifest, resolveMcpServers, mcpForScenario, resolveA2aPeers, a2aForScenario } from "./web-admin-client/facade.js";
 import { hostExecutionEnvFactory } from "./plugins/remote-env-host.js";
-import { executionLaneHomeDir, executionLaneOf } from "./execution-lane-caps.js";
+import { buildLaneHomeClaim, executionLaneOf } from "./execution-lane-caps.js";
 import { makeLoadProjectMemory, makeProbeInstructionSources } from "./project-memory.js";
 import { createInstructionSourceSeat } from "./instruction-source-notice.js";
 import { loadDeploymentSkills } from "./capabilities/skills.js";
@@ -42,12 +42,13 @@ import { createTaskListLane } from "./boot/task-list-lane.js";
 import { pickHandsRunner, withoutHands } from "./capabilities/hands-lane.js";
 import { HttpError, sessionIdShapeIssue } from "./security.js";
 import { createMemoryEngineIncidentSink } from "./memory-incident-sink.js";
-import { fileMemoryEngineRoot, memoryEngineBackendFor, memorySpecForRequest } from "./memory-scope.js";
+import { fileMemoryEngineRoot, memoryEngineBackendFor, memoryLayersNamedBy, memorySpecForRequest } from "./memory-scope.js";
+import { createMemoryScopeStores } from "./memory-scope-stores.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 { buildMemorySyncEnabledFields, createMemorySyncRunner, createMemorySyncTransport } from "./memory-sync-client.js";
+import { startMemorySyncRunner } 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";
@@ -472,17 +473,22 @@ export async function runLocal(argv, deps = {}) {
     const hostRx = config.remoteExec?.provider === "host" ? config.remoteExec : undefined;
     const workspaceDir = args.workspace ?? hostRx?.workspaceBase ?? process.cwd();
     await settleHostLaneShell(config, logger);
+    warnReadDenyFloorUnkept(config, logger);
+    const homeDirSeat = buildLaneHomeClaim(config);
     const executionEnvFactory = hostRx
         ? hostExecutionEnvFactory({
             workspaceDir,
-            ...((h) => (h === undefined ? {} : { homeDir: h }))(executionLaneHomeDir(config)),
+            ...homeDirSeat,
             backgroundShell: config.requirePrincipal !== true,
             ...(hostRx.commandTimeoutMs != null ? { commandTimeoutMs: hostRx.commandTimeoutMs } : {}),
         })
         : undefined;
     const lspManager = hostRx && config.lspHostEnabled && config.requirePrincipal !== true ? createHostLspManager(config, (event, fields) => logger.info(event, fields)) : undefined;
-    const memoryEngine = memoryEngineBackendFor(config, root, memoryEngineIncident);
     const engineDataRoot = fileMemoryEngineRoot(config, root);
+    const fileEngine = memoryEngineBackendFor(config, root, memoryEngineIncident);
+    const memoryEngine = fileEngine !== undefined
+        ? createMemoryScopeStores({ backend: fileEngine.backend, root: engineDataRoot, namedLayers: () => memoryLayersNamedBy({ ...config, memoryScope: args.user ?? "local" }), onIncident: memoryEngineIncident })
+        : undefined;
     try {
         judgeConsolidationValve({ config, memoryEngine });
     }
@@ -494,18 +500,7 @@ export async function runLocal(argv, deps = {}) {
     }
     let memorySync;
     if (config.memorySync && memoryEngine) {
-        const transport = createMemorySyncTransport({ url: config.memorySync.url, token: config.memorySync.token });
-        memorySync = createMemorySyncRunner({
-            backend: memoryEngine.backend,
-            scope: config.memorySync.scope,
-            memoryRoot: memoryEngine.root,
-            transport,
-            log: logger,
-            ...(config.memorySync.maxPushEntries !== undefined ? { maxPushEntries: config.memorySync.maxPushEntries } : {}),
-            ...(config.memorySync.maxPullEntries !== undefined ? { maxPullEntries: config.memorySync.maxPullEntries } : {}),
-        });
-        logger.info("memory_sync_enabled", buildMemorySyncEnabledFields(transport.peer, config.memorySync.scope, memorySync.cursorPathFor(config.memorySync.scope)));
-        memorySync.trigger("boot");
+        memorySync = startMemorySyncRunner({ sync: config.memorySync, stores: memoryEngine, log: logger });
     }
     else if (config.memorySync) {
         logger.warn("memory_sync_configured_but_memory_dark", { note: "MEMORY_SYNC_URL is set but the file memory engine is dark (MEMORY_ENGINE=off / remote exec lane) — no sync rounds will run" });
@@ -687,7 +682,7 @@ export async function runLocal(argv, deps = {}) {
         }
     }
     const projectKey = memoryEngine
-        ? await createMemoryProjectLayers({ backend: memoryEngine.backend, syncRunner: memorySync, log: logger }).prepare(config, scope, workspaceDir)
+        ? await createMemoryProjectLayers({ stores: memoryEngine, syncRunner: memorySync, log: logger }).prepare(config, scope, workspaceDir)
         : undefined;
     const taskTimeoutSec = Math.floor(parseNumOrFailNonNegative("TASK_TIMEOUT_SEC", process.env.TASK_TIMEOUT_SEC || "0"));
     const timeoutSec = taskWallClockSec(taskTimeoutSec, false);

package/dist/runs.d.ts

@@ -263,10 +263,14 @@ export declare function graftParkToolCallId<T>(result: T, cs: ParkCheckpointRead
  * Preemption (POST /v1/assistant/tasks/:id/preempt, [ref] seam #2): a SECOND, INDEPENDENT controller
  * (`preemptCtrl`, registered in `preemptable`) carries the scheduler's graceful "yield this task" — when raised,
  * core durably SUSPENDS the task at the next clean turn boundary (gate resource_limit, reason "preempt") so it is
- * RESUMABLE, the opposite of cancel's kill. It is wired ONLY on the plain-stream path: the verify/cascade
- * branches finalize with `setTerminal` unconditionally (no `setSuspended`), so a preempt-suspend there would write
- * a non-terminal "suspended" as terminal and release the session lock — and preempt's contract is graceful, not a
- * failure. Cross-replica via the `preempt_requested` flag (same heartbeat tick). Eligibility (resourceSuspend +
+ * RESUMABLE, the opposite of cancel's kill. It is wired ONLY on the plain-stream path. A cascade cannot honor it: a
+ * rung's pause lands on the rung's own engine-minted session, which the host's resume chain cannot reach (the
+ * host-boundary judge settles it terminal). A verify task carries the resource-suspend opt-in (a budget / turns /
+ * walltime limit parks its implementation leg or fix round), but its FIRST slice here is not wired to the preempt
+ * signal (`preemptEligible` below is false for verify, so the preempt endpoint answers a no-op for a verify run this
+ * replica owns); a RESUMED verify leg is wired (`resume-legs.ts` registers every resume leg in `preemptableRuns` and
+ * threads `preemptSignal` into `resumeWithVerification`). Cross-replica via the `preempt_requested` flag (same heartbeat
+ * tick). Eligibility (resourceSuspend +
  * durable store + durable tool-results + remote env) is core's call: an ineligible task's preemptSignal no-ops.
  *
  * Steering (POST /v1/runs/:id/steer, [ref]): the live core `TaskStream` is registered in `steerable` so the