@sema-agent/server 7.147.0 → 7.148.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, 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);
     }
@@ -52,13 +59,19 @@ 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();
         this.active.set(sessionId, taskId);
@@ -86,6 +99,21 @@ export class MemoryRunStore {
             this.byIdem.set(idemKey, taskId);
         return { ok: true };
     }
+    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 releaseIdemKey(taskId) {
         const r = this.runs.get(taskId);
         if (!r)
@@ -141,6 +169,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 +215,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,
@@ -212,6 +241,7 @@ export class MemoryRunStore {
         if (r && (r.status === "running" || r.status === "suspended")) {
             r.status = "suspended";
             r.result = sealed;
+            r.errorCode = runRowErrorCodeOf(sealed);
             r.updatedAt = new Date();
         }
     }
@@ -221,6 +251,7 @@ export class MemoryRunStore {
         if (r && (r.status === "running" || r.status === "needs_review")) {
             r.status = "needs_review";
             r.result = sealed;
+            r.errorCode = runRowErrorCodeOf(sealed);
             r.updatedAt = new Date();
         }
     }
@@ -230,6 +261,7 @@ export class MemoryRunStore {
             return false;
         r.status = "running";
         r.result = null;
+        r.errorCode = null;
         r.instanceId = instanceId;
         r.cancelRequested = false;
         r.preemptRequested = false;
@@ -289,62 +321,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 +364,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,10 @@
+/**
+ * **一次性迁移的标记表**(SQL 两方言)—— 需要「这一库上这一条已经判过 / 落过」这一事实的迁移各在这里记一行(键 = 登记表里的那一条名,`plugins/one-time-migrations.ts`)。
+ * 表由用到它的那一步自己建(不进中央建表语句:它随最后一条读它的迁移删码,库里留下的空表无人读,起服列册对账只核本树声明的表)。最后一条读它的迁移删码时,本文件一起删。
+ */
+import type { SqlDialect } from "./sql-driver.js";
+/** 标记表名。 */
+export declare const MIGRATION_MARKER_TABLE = "one_time_migration_marker";
+/** 标记表的建表句(两方言;幂等)。 */
+export declare function migrationMarkerDdl(dialect: SqlDialect): string;
+//# sourceMappingURL=one-time-migration-marker.d.ts.map

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

@@ -0,0 +1,7 @@
+export const MIGRATION_MARKER_TABLE = "one_time_migration_marker";
+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)`
+        : `CREATE TABLE IF NOT EXISTS ${MIGRATION_MARKER_TABLE} (migration_id VARCHAR(16) COLLATE "C" NOT NULL PRIMARY KEY, marked_at_ms BIGINT NOT NULL)`;
+}
+//# sourceMappingURL=one-time-migration-marker.js.map