@sema-agent/server 7.147.0 → 7.149.0

package/dist/plugins/memory-run-store.js

@@ -1,7 +1,8 @@
-import { redactErrorMessage, redactLedgerEventData, sealRunRowResult } from "../observability/run-terminal.js";
+import { redactErrorMessage, redactLedgerEventData, runRowErrorCodeOf, sealRunRowResult } from "../observability/run-terminal.js";
 import { outwardPlane } from "../terminal.js";
 import { projectUsageStats, USAGE_SCAN_LIMIT } from "../usage-analytics.js";
-import { RUN_HOLDER_DEATH_CODES, RUN_STALLED_ERROR, isTerminalRunStatus, settledLegObservationOf } from "./store-contracts.js";
+import { RUN_HOLDER_DEATH_CODES, RUN_STALLED_ERROR, RUN_STALL_DEFAULT_WIRING, isTerminalRunStatus, mintRunLegId, runLivenessOf, settledLegObservationOf } from "./store-contracts.js";
+import { buildSessionRunRollups } from "./session-run-rollup.js";
 import { notifyRunTerminal } from "../observability/run-terminal.js";
 import { createInProcessSpaceCommitTable, fenceSpaceCommitAtTerminal } from "../workspace-space-commit.js";
 const ownerEq = (a, b) => (a ?? null) === (b ?? null);
@@ -17,6 +18,12 @@ export class MemoryRunStore {
         save: (record) => void this.spaceCommitRecords.set(record.spaceKey, record),
         remove: (spaceKey) => void this.spaceCommitRecords.delete(spaceKey),
     });
+    rootRows;
+    stall;
+    constructor(opts) {
+        this.rootRows = opts?.rootRows;
+        this.stall = opts?.stall ?? RUN_STALL_DEFAULT_WIRING;
+    }
     readSpaceCommit(spaceKey) {
         return this.spaceCommits.readSpaceCommit(spaceKey);
     }
@@ -45,6 +52,7 @@ export class MemoryRunStore {
             source: r.source,
             identity: r.identity,
             instanceId: r.instanceId,
+            legId: r.legId,
             cancelRequested: r.cancelRequested,
             objectivePreview: r.objectivePreview,
             createdAt: r.createdAt.toISOString(),
@@ -52,15 +60,22 @@ export class MemoryRunStore {
         };
     }
     async createRun(taskId, sessionId, owner, instanceId, meta = {}) {
+        const rootRows = this.rootRows;
+        if (rootRows === undefined)
+            return this.createRunClaimed(taskId, sessionId, owner, instanceId, meta);
+        return rootRows().withRootRow(sessionId, async (present) => (present ? this.createRunClaimed(taskId, sessionId, owner, instanceId, meta) : { ok: false, sessionAbsent: true }));
+    }
+    createRunClaimed(taskId, sessionId, owner, instanceId, meta) {
         const idemKey = meta.idem?.key ?? null;
         const byKey = idemKey !== null ? this.byIdem.get(idemKey) : undefined;
         const existing = (byKey !== undefined ? this.runs.get(byKey) : undefined) ?? this.runs.get(taskId);
         if (existing)
             return { ok: false, existing: this.toRecord(existing) };
         const claimed = this.active.get(sessionId);
-        if (claimed !== undefined)
+        if (claimed !== undefined && !this.settleDueHolder(claimed))
             return { ok: false, activeTaskId: claimed };
         const now = new Date();
+        const legId = mintRunLegId();
         this.active.set(sessionId, taskId);
         this.runs.set(taskId, {
             taskId,
@@ -73,6 +88,7 @@ export class MemoryRunStore {
             jobId: meta.jobId ?? null,
             source: meta.source ?? null,
             instanceId,
+            legId,
             objectivePreview: meta.objectivePreview ?? null,
             idemKey,
             idemBodyFingerprint: meta.idem?.bodyFingerprint ?? null,
@@ -84,16 +100,50 @@ export class MemoryRunStore {
         });
         if (idemKey !== null)
             this.byIdem.set(idemKey, taskId);
-        return { ok: true };
+        return { ok: true, legId };
+    }
+    withdrawRunsOf(sessionId, ownTaskId) {
+        for (const r of this.runs.values())
+            if (r.sessionId === sessionId && r.taskId !== ownTaskId)
+                return { keep: "runs" };
+        const own = ownTaskId === undefined ? undefined : this.runs.get(ownTaskId);
+        if (own === undefined)
+            return "proceed";
+        if (own.sessionId !== sessionId)
+            throw new Error(`MemoryRunStore.withdrawRunsOf: run ${ownTaskId} belongs to session ${own.sessionId}, not ${sessionId} — refusing to delete it`);
+        this.events.delete(own.taskId);
+        if (own.idemKey !== null && this.byIdem.get(own.idemKey) === own.taskId)
+            this.byIdem.delete(own.idemKey);
+        this.runs.delete(own.taskId);
+        return "proceed";
+    }
+    async withdrawMintedRun(taskId, legId) {
+        const r = this.runs.get(taskId);
+        if (r === undefined || r.legId !== legId)
+            return false;
+        if (r.status !== "running") {
+            if (isTerminalRunStatus(r.status))
+                this.dropIdemBinding(r);
+            return false;
+        }
+        this.events.delete(taskId);
+        if (r.idemKey !== null && this.byIdem.get(r.idemKey) === taskId)
+            this.byIdem.delete(r.idemKey);
+        this.runs.delete(taskId);
+        if (this.active.get(r.sessionId) === taskId)
+            this.active.delete(r.sessionId);
+        return true;
     }
     async releaseIdemKey(taskId) {
         const r = this.runs.get(taskId);
-        if (!r)
-            return;
+        if (r)
+            this.dropIdemBinding(r);
+    }
+    dropIdemBinding(r) {
         r.idemBodyFingerprint = null;
         if (r.idemKey === null)
             return;
-        if (this.byIdem.get(r.idemKey) === taskId)
+        if (this.byIdem.get(r.idemKey) === r.taskId)
             this.byIdem.delete(r.idemKey);
         r.idemKey = null;
     }
@@ -141,6 +191,7 @@ export class MemoryRunStore {
         const r = this.runs.get(taskId);
         if (r && ownerEq(r.owner, owner) && r.status === "running")
             r.updatedAt = new Date();
+        return r !== undefined && r.status === "running";
     }
     async appendEvent(taskId, seq, type, data) {
         data = redactLedgerEventData(type, data);
@@ -186,7 +237,7 @@ export class MemoryRunStore {
             r.status = status;
             r.result = result;
             r.error = error;
-            r.errorCode = result === null ? null : (outwardPlane(result.terminal).errorCode ?? null);
+            r.errorCode = runRowErrorCodeOf(result);
             r.updatedAt = new Date();
             pending = {
                 runId: taskId,
@@ -206,35 +257,42 @@ export class MemoryRunStore {
             notifyRunTerminal(pending);
         return fenced;
     }
-    async setSuspended(taskId, result) {
+    async setSuspended(taskId, result, legId) {
         const sealed = sealRunRowResult(result);
         const r = this.runs.get(taskId);
-        if (r && (r.status === "running" || r.status === "suspended")) {
-            r.status = "suspended";
-            r.result = sealed;
-            r.updatedAt = new Date();
-        }
+        if (!r || r.legId !== legId || (r.status !== "running" && r.status !== "suspended") || r.cancelRequested)
+            return false;
+        r.status = "suspended";
+        r.result = sealed;
+        r.errorCode = runRowErrorCodeOf(sealed);
+        r.updatedAt = new Date();
+        return true;
     }
-    async setNeedsReview(taskId, result) {
+    async setNeedsReview(taskId, result, legId) {
         const sealed = sealRunRowResult(result);
         const r = this.runs.get(taskId);
-        if (r && (r.status === "running" || r.status === "needs_review")) {
-            r.status = "needs_review";
-            r.result = sealed;
-            r.updatedAt = new Date();
-        }
+        if (!r || r.legId !== legId || (r.status !== "running" && r.status !== "needs_review") || r.cancelRequested)
+            return false;
+        r.status = "needs_review";
+        r.result = sealed;
+        r.errorCode = runRowErrorCodeOf(sealed);
+        r.updatedAt = new Date();
+        return true;
     }
     async markResuming(taskId, instanceId) {
         const r = this.runs.get(taskId);
         if (!r || (r.status !== "suspended" && r.status !== "needs_review"))
-            return false;
+            return undefined;
+        const legId = mintRunLegId();
         r.status = "running";
         r.result = null;
+        r.errorCode = null;
         r.instanceId = instanceId;
+        r.legId = legId;
         r.cancelRequested = false;
         r.preemptRequested = false;
         r.updatedAt = new Date();
-        return true;
+        return legId;
     }
     async getActiveTaskId(sessionId) {
         return this.active.get(sessionId);
@@ -289,62 +347,10 @@ export class MemoryRunStore {
         }
         return latest === undefined ? undefined : settledLegObservationOf(latest.taskId, latest.result);
     }
-    async listSessions(opts) {
-        const bySession = new Map();
-        for (const r of this.runs.values()) {
-            if (opts.owner !== undefined && r.owner !== opts.owner && !(opts.includeUnowned === true && r.owner === null))
-                continue;
-            const arr = bySession.get(r.sessionId) ?? [];
-            arr.push(r);
-            bySession.set(r.sessionId, arr);
-        }
-        const cursorAt = opts.cursor ? Date.parse(opts.cursor.lastActivityAt) : undefined;
-        const qlc = opts.q?.toLowerCase();
-        const summaries = [];
-        for (const [sessionId, arr] of bySession) {
-            if (qlc && !arr.some((r) => r.objectivePreview?.toLowerCase().includes(qlc)))
-                continue;
-            const sorted = [...arr].sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime() || (a.taskId < b.taskId ? 1 : a.taskId > b.taskId ? -1 : 0));
-            const latest = sorted[0];
-            const latestRunId = latest.result?.runId;
-            let last = -Infinity;
-            let first = Infinity;
-            for (const r of arr) {
-                const t = r.createdAt.getTime();
-                if (t > last)
-                    last = t;
-                if (t < first)
-                    first = t;
-            }
-            summaries.push({
-                sessionId,
-                owner: latest.owner,
-                lastActivityAt: new Date(last).toISOString(),
-                firstActivityAt: new Date(first).toISOString(),
-                runCount: arr.length,
-                objectivePreview: latest.objectivePreview,
-                lastStatus: latest.status,
-                lastRunId: latest.taskId,
-                ...(typeof latestRunId === "string" && latestRunId !== "" ? { lastTaskRunId: latestRunId } : {}),
-                title: null,
-                pinned: false,
-            });
-        }
-        return summaries
-            .filter((s) => {
-            if (cursorAt === undefined)
-                return true;
-            const t = Date.parse(s.lastActivityAt);
-            return t < cursorAt || (t === cursorAt && s.sessionId < opts.cursor.sessionId);
-        })
-            .sort((a, b) => Date.parse(b.lastActivityAt) - Date.parse(a.lastActivityAt) || (a.sessionId < b.sessionId ? 1 : a.sessionId > b.sessionId ? -1 : 0))
-            .slice(0, opts.limit);
+    async sessionRunRollups(opts = {}) {
+        return buildSessionRunRollups(this.runs.values(), opts);
     }
-    async deleteBySession(sessionId, expectedSessionOwner) {
-        void expectedSessionOwner;
-        const claimed = this.active.get(sessionId);
-        if (claimed !== undefined)
-            return { active: claimed };
+    async deleteBySession(sessionId) {
         let removed = 0;
         for (const [taskId, r] of [...this.runs]) {
             if (r.sessionId !== sessionId)
@@ -384,22 +390,44 @@ export class MemoryRunStore {
         }
         return [...counts.values()];
     }
-    async reapStale(olderThanMs) {
-        const cutoff = Date.now() - olderThanMs;
+    async reapStale() {
+        const nowMs = Date.now();
+        const windowMs = this.stall.windowMs();
         let reaped = 0;
-        for (const r of this.runs.values()) {
-            if (r.status === "running" && r.updatedAt.getTime() < cutoff) {
-                r.status = "failed";
-                r.result = null;
-                r.error = RUN_STALLED_ERROR;
-                r.errorCode = RUN_HOLDER_DEATH_CODES.stalled;
-                r.updatedAt = new Date();
+        for (const r of this.runs.values())
+            if (this.landStallVerdict(r, nowMs, windowMs))
                 reaped += 1;
-            }
-        }
         this.releaseTerminalClaims();
+        if (reaped > 0)
+            this.stall.onVerdicts(reaped);
         return reaped;
     }
+    landStallVerdict(r, nowMs, windowMs) {
+        if (runLivenessOf(this.toRecord(r), nowMs, windowMs) !== "due")
+            return false;
+        r.status = "failed";
+        r.result = null;
+        r.error = RUN_STALLED_ERROR;
+        r.errorCode = RUN_HOLDER_DEATH_CODES.stalled;
+        r.updatedAt = new Date();
+        return true;
+    }
+    settleDueHolder(holderTaskId) {
+        const r = this.runs.get(holderTaskId);
+        if (r === undefined || !this.landStallVerdict(r, Date.now(), this.stall.windowMs()))
+            return false;
+        if (this.active.get(r.sessionId) === holderTaskId)
+            this.active.delete(r.sessionId);
+        this.stall.onVerdicts(1);
+        return true;
+    }
+    async observeRun(row) {
+        const r = this.runs.get(row.taskId);
+        if (r === undefined || runLivenessOf(row, Date.now(), this.stall.windowMs()) !== "due")
+            return row;
+        this.settleDueHolder(row.taskId);
+        return this.toRecord(r);
+    }
     failExpiredPark(r) {
         r.status = "failed";
         r.result = null;

package/dist/plugins/one-time-migration-marker.d.ts

@@ -0,0 +1,26 @@
+/**
+ * **标记表**(SQL 两方言)—— 一库一行一事实,键 = 落它的那一条一次性迁移的名(`plugins/one-time-migrations.ts` 登记表)。两类行:
+ *  · **一次性的标记**:需要「这一库上这一条已经判过 / 落过」的迁移各记一行(M42 / M43 / M51),随那一条删码后无人再读(行留着无害);
+ *  · **常设的一行 —— `Skill` 豁免截点**({@link SKILL_EXEMPTION_CUTOFF_ID}):T0 = 一只按今天的意思读会话豁免行的构建第一次接管这只库的时刻。
+ *    首次放行早于它的引擎家 `Skill` 豁免行是更早的意思写下的(批准 = 激活某技能),读者 = 跳版拒启臂 `approval-exemption-skill-cutoff.ts`(无窗)与一次性迁移 M46(窗内删那些行)。
+ * 表是常设的:中央建表语句建它(`tidb-pool.ts` / `pg-pool.ts`),`ensureSchema()` 在建表之后落截点那一行(只在缺席时落 —— 「此刻这只库由知道今天读法的构建接管」)。
+ */
+import type { SqlDialect } from "./sql-driver.js";
+/** 标记表名。 */
+export declare const MIGRATION_MARKER_TABLE = "one_time_migration_marker";
+/**
+ * 常设的那一行的键:`Skill` 豁免截点 T0(`marked_at_ms` = T0 的 epoch 毫秒)。键沿用第一个落它的一次性迁移 M46 的名 —— 7.148.0 起的库里已经是这一行,
+ * 改名就要再迁一次;M46 删码之后这一行照旧是截点的家。
+ */
+export declare const SKILL_EXEMPTION_CUTOFF_ID = "M46";
+/**
+ * 标记表的建表句(两方言;幂等)。中央建表语句与一次性迁移的步骤读同一只。键列与中央各表同形钉二进制排序(MySQL 协议表级 `COLLATE utf8mb4_bin`、PG 列级 `"C"`),
+ * 不继承库的缺省排序;7.148.0 由迁移建下的那一张(MySQL 协议上没钉表级排序)`IF NOT EXISTS` 不动它 —— 键是固定的 ASCII 迁移名,列册对账不看排序规则。
+ */
+export declare function migrationMarkerDdl(dialect: SqlDialect): string;
+/**
+ * 落一行标记、只在缺席时落(两方言;参数 `[键, 毫秒]`;已在 ⇒ 零改动,先落的那一只赢 —— 并发起服收敛到同一个值)。本表唯一的写句:
+ * `ensureSchema()` 的截点种子行与一次性迁移的各步同读这一只。
+ */
+export declare function markIfAbsentSql(dialect: SqlDialect): string;
+//# sourceMappingURL=one-time-migration-marker.d.ts.map

package/dist/plugins/one-time-migration-marker.js

@@ -0,0 +1,13 @@
+export const MIGRATION_MARKER_TABLE = "one_time_migration_marker";
+export const SKILL_EXEMPTION_CUTOFF_ID = "M46";
+export function migrationMarkerDdl(dialect) {
+    return dialect === "mysql"
+        ? `CREATE TABLE IF NOT EXISTS ${MIGRATION_MARKER_TABLE} (migration_id VARCHAR(16) NOT NULL PRIMARY KEY, marked_at_ms BIGINT NOT NULL) COLLATE utf8mb4_bin`
+        : `CREATE TABLE IF NOT EXISTS ${MIGRATION_MARKER_TABLE} (migration_id VARCHAR(16) COLLATE "C" NOT NULL PRIMARY KEY, marked_at_ms BIGINT NOT NULL)`;
+}
+export function markIfAbsentSql(dialect) {
+    return dialect === "mysql"
+        ? `INSERT INTO ${MIGRATION_MARKER_TABLE} (migration_id, marked_at_ms) VALUES (?, ?) ON DUPLICATE KEY UPDATE migration_id = migration_id`
+        : `INSERT INTO ${MIGRATION_MARKER_TABLE} (migration_id, marked_at_ms) VALUES ($1, $2) ON CONFLICT (migration_id) DO NOTHING`;
+}
+//# sourceMappingURL=one-time-migration-marker.js.map