@sema-agent/server 7.54.0 → 7.55.0

package/dist/tool-approval.js

@@ -8,6 +8,7 @@ import { createLogger } from "./observability/logger.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { deriveAskId, deriveBatchId, MAX_DECISION_NOTE_CHARS } from "./approval-ask-machine.js";
 import { ApprovalCardEnvelopeSchema, MAX_RULE_OFFERS, buildApprovalCard, buildApprovalCardEnvelope, buildApprovalRequestFrame, buildRevokeFrame, readProbeCause, readRuleEvidence, readRuleOffersAbsence, } from "./approval-card.js";
+import { projectAskTerminalClaimTruth } from "./plugins/approval-ask-store-sql.js";
 import { governanceAskMarksFor, runWithGovernanceAskScope } from "./governance-ask-marks.js";
 const defaultLogger = createLogger();
 export const APPROVAL_GATE_KINDS = ["human", "irreversible_ask"];
@@ -43,9 +44,12 @@ function durableRuleMaterial(material) {
     return { ruleCommand: material.command, ruleScopeRoot: material.scopeRoot ?? null };
 }
 export const ASK_DECISION_CONSUMER_ABSENT = "absent";
+const MAX_INFLIGHT_TERMINAL_CLAIMS = 2;
 const DURABLE_CONVERGE_BACKOFF_MS = [50, 100, 200, 400, 800, 1600];
 const DURABLE_CONVERGE_READ_TIMEOUT_MS = 2_000;
 const DURABLE_CALL_TIMEOUT_MS = 5_000;
+const TERMINAL_LADDER_WALL_MS = DURABLE_CALL_TIMEOUT_MS + DURABLE_CONVERGE_READ_TIMEOUT_MS + DURABLE_CONVERGE_BACKOFF_MS.reduce((a, b) => a + b, 0);
+const TERMINAL_CLAIM_CAP_POLL_MS = 50;
 function ambiguousCasFailOpenTag(intent) {
     switch (intent) {
         case "expire":
@@ -228,6 +232,30 @@ function settleArgsOf(outcome) {
 export class ToolApprovalCoordinator {
     als = new AsyncLocalStorage();
     pending = new Map();
+    terminalClaimsInFlight = new Map();
+    admitTerminalClaim(askId) {
+        const n = this.terminalClaimsInFlight.get(askId) ?? 0;
+        if (n >= MAX_INFLIGHT_TERMINAL_CLAIMS)
+            return undefined;
+        this.terminalClaimsInFlight.set(askId, n + 1);
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            const cur = this.terminalClaimsInFlight.get(askId) ?? 0;
+            if (cur <= 1)
+                this.terminalClaimsInFlight.delete(askId);
+            else
+                this.terminalClaimsInFlight.set(askId, cur - 1);
+        };
+    }
+    terminalClaimsInFlightCount(askId) {
+        return this.terminalClaimsInFlight.get(askId) ?? 0;
+    }
+    terminalClaimsInFlightForTest(askId) {
+        return this.terminalClaimsInFlightCount(askId);
+    }
     pendingByAskId = new Map();
     allowAllSessions = new Set();
     streams = new Map();
@@ -253,6 +281,7 @@ export class ToolApprovalCoordinator {
     parkTombstoneTtlMs;
     parkTombstonePerPrincipalMax;
     parkedRedeem;
+    askAudit;
     constructor(opts) {
         this.ruleConsent = opts?.ruleConsent;
         this.ruleScopeRootFor = opts?.ruleScopeRootFor;
@@ -268,6 +297,7 @@ export class ToolApprovalCoordinator {
         this.parkTombstoneMax = opts?.parkTombstoneMax ?? DEFAULT_PARK_TOMBSTONE_MAX;
         this.parkTombstoneTtlMs = opts?.parkTombstoneTtlMs ?? DEFAULT_PARK_TOMBSTONE_TTL_MS;
         this.parkTombstonePerPrincipalMax = opts?.parkTombstonePerPrincipalMax ?? DEFAULT_PARK_TOMBSTONE_PER_PRINCIPAL_MAX;
+        this.askAudit = opts?.askAudit;
     }
     unattendedOutcome() {
         return this.unattendedPolicy === "deny" ? false : "unavailable";
@@ -454,23 +484,30 @@ export class ToolApprovalCoordinator {
             return false;
         }
     }
-    async readRowForRecovery(askId, where) {
-        if (!this.askStore)
-            return { kind: "absent" };
+    async probeRowWhileYielding(askId, budgetMs) {
+        if (!this.askStore || budgetMs <= 0)
+            return { kind: "none" };
+        const release = this.admitTerminalClaim(askId);
+        if (release === undefined)
+            return { kind: "denied" };
+        const raw = this.askStore.getAsk(askId);
+        void raw.then(release, release);
         let row;
         try {
-            row = await this.withStoreDeadline(this.askStore.getAsk(askId), `getAsk(${where})`, DURABLE_CONVERGE_READ_TIMEOUT_MS);
+            row = await this.withStoreDeadline(raw, "getAsk(yield-probe)", Math.min(DURABLE_CONVERGE_READ_TIMEOUT_MS, budgetMs));
         }
         catch (err) {
-            this.noteStoreError(err, `getAsk(${where})`);
-            return { kind: "unreadable" };
+            this.noteStoreError(err, "getAsk(yield-probe)");
+            return { kind: "none" };
         }
-        if (row === null)
+        if (row === null || row.state === "STREAM_PENDING")
+            return { kind: "none" };
+        return { kind: "row", current: projectAskTerminalClaimTruth(row) };
+    }
+    classifyClaimLoss(askId, current, where) {
+        if (current.state === "absent")
             return { kind: "absent" };
-        if (row.state === "STREAM_PENDING") {
-            return this.editedDecisionInFlight(askId) ? { kind: "edit-in-flight" } : { kind: "pending" };
-        }
-        const replayed = settleArgsOf(this.guardRowDerivedApprove(askId, replayTerminalAskRow(row), where));
+        const replayed = settleArgsOf(this.guardRowDerivedApprove(askId, replayTerminalAskRow(current), where));
         if (replayed === "unavailable")
             return { kind: "parked" };
         if (!replayed.allowed)
@@ -631,6 +668,7 @@ export class ToolApprovalCoordinator {
                     if (p.targetCtxs?.has(ctx))
                         p.onTargetGone?.(ctx);
                 }
+                this.askAudit?.noteLegClosed(ctx.taskId);
             }
         }));
     }
@@ -923,111 +961,159 @@ export class ToolApprovalCoordinator {
             releaseAdmission();
             if (selfEntry)
                 selfEntry.settledOutcome = outcome;
+            this.askAudit?.recordSettle({
+                approvalId: wireApprovalId,
+                outcome,
+                ...(windowRouteUnavailable ? { parkRouted: true } : {}),
+                ...(hostSettledBy !== undefined ? { settledBy: hostSettledBy } : {}),
+                settledAtMs: Date.now(),
+            });
             resolveAllowed({ allowed, ...(allowed && updatedInput !== undefined ? { updatedInput } : {}) });
         };
-        const convergeFromDurableState = async (where) => {
-            if (!this.askStore || askId === undefined)
+        const broadcastClaimTruth = (read) => {
+            if (askId === undefined)
                 return;
-            const pinnedAskId = askId;
-            for (let attempt = 0; attempt <= DURABLE_CONVERGE_BACKOFF_MS.length; attempt++) {
-                if (done)
+            switch (read.kind) {
+                case "approved":
+                    this.notifyExternalDecision(askId, true, read.updatedInput);
                     return;
-                const read = await this.readRowForRecovery(pinnedAskId, `converge:${where}`);
-                if (done)
+                case "denied":
+                    this.notifyExternalDecision(askId, false);
                     return;
-                switch (read.kind) {
-                    case "absent":
-                        settle(false, "expired");
-                        return;
-                    case "pending":
-                    case "edit-in-flight":
-                    case "unreadable":
-                        if (attempt < DURABLE_CONVERGE_BACKOFF_MS.length)
-                            await new Promise((r) => setTimeout(r, DURABLE_CONVERGE_BACKOFF_MS[attempt]).unref?.());
-                        continue;
-                    case "parked":
-                        windowRouteUnavailable = true;
-                        settle(false, "expired");
-                        return;
-                    case "approved":
-                        settle(true, "allowed", read.updatedInput);
-                        return;
-                    case "denied":
-                        settle(false, "denied");
-                        return;
-                    default: {
-                        const unreachable = read;
-                        throw new Error(`convergeFromDurableState: unknown recovery read ${String(unreachable)}`);
-                    }
+                case "parked":
+                    this.settleSameAskIdParkRoute(askId);
+                    return;
+                case "absent":
+                case "edit-in-flight":
+                    return;
+                default: {
+                    const unreachable = read;
+                    throw new Error(`broadcastClaimTruth: unknown recovery read ${String(unreachable)}`);
                 }
             }
-            if (!done) {
-                if (this.editedDecisionInFlight(pinnedAskId)) {
+        };
+        const settleFromClaimLoss = (read) => {
+            switch (read.kind) {
+                case "approved":
+                    settle(true, "allowed", read.updatedInput);
+                    broadcastClaimTruth(read);
+                    return true;
+                case "denied":
+                    settle(false, "denied");
+                    broadcastClaimTruth(read);
+                    return true;
+                case "parked":
                     windowRouteUnavailable = true;
                     settle(false, "expired");
-                }
-                else {
-                    settle(false, "expired");
+                    broadcastClaimTruth(read);
+                    return true;
+                case "absent":
+                case "edit-in-flight":
+                    return false;
+                default: {
+                    const unreachable = read;
+                    throw new Error(`settleFromClaimLoss: unknown recovery read ${String(unreachable)}`);
                 }
             }
         };
-        const recoverFromUnknownStore = async (arm, casStillInFlight) => {
+        const lateClaimLossSettle = (current, intent) => {
+            if (askId === undefined)
+                return;
+            const read = this.classifyClaimLoss(askId, current, `late:${intent}`);
+            if (done) {
+                broadcastClaimTruth(read);
+                return;
+            }
+            settleFromClaimLoss(read);
+        };
+        const boundedClaim = (mk, label, timeoutMs, late) => {
+            const release = this.admitTerminalClaim(askId ?? wireApprovalId);
+            if (release === undefined)
+                return undefined;
+            const raw = mk();
+            void raw.then(release, release);
+            return this.withStoreDeadline(raw, label, timeoutMs, late);
+        };
+        const resolveLocalOutcome = async (arm) => {
             if (askId === undefined) {
                 arm.settleByIntent();
                 return;
             }
             const pinnedAskId = askId;
-            for (let attempt = 0; attempt <= DURABLE_CONVERGE_BACKOFF_MS.length; attempt++) {
-                if (done)
-                    return;
-                const read = await this.readRowForRecovery(pinnedAskId, `recovery:${arm.intent}`);
+            let lastLoss;
+            const ladderStartedAt = Date.now();
+            const remainingMs = () => ladderStartedAt + TERMINAL_LADDER_WALL_MS - Date.now();
+            const nap = async (ms) => {
+                const slice = Math.min(ms, remainingMs());
+                if (slice > 0)
+                    await new Promise((r) => setTimeout(r, slice).unref?.());
+            };
+            let attempt = 0;
+            let claimsIssued = 0;
+            let rejects = 0;
+            while (attempt <= DURABLE_CONVERGE_BACKOFF_MS.length && remainingMs() > 0) {
                 if (done)
                     return;
-                switch (read.kind) {
-                    case "approved":
-                        settle(true, "allowed", read.updatedInput);
-                        return;
-                    case "denied":
-                        settle(false, "denied");
-                        return;
-                    case "parked":
-                        windowRouteUnavailable = true;
-                        settle(false, "expired");
+                const backoffAfter = attempt < DURABLE_CONVERGE_BACKOFF_MS.length ? DURABLE_CONVERGE_BACKOFF_MS[attempt] : 0;
+                if (attempt > 0 && this.editedDecisionInFlight(pinnedAskId)) {
+                    const probed = await this.probeRowWhileYielding(pinnedAskId, remainingMs());
+                    if (done)
                         return;
-                    case "pending": {
-                        if (casStillInFlight) {
-                            arm.settleByIntent();
-                            return;
-                        }
-                        let result;
-                        try {
-                            result = await arm.cas();
-                        }
-                        catch (err) {
-                            this.noteStoreError(err, arm.storeLabel);
-                            arm.settleByIntent();
-                            return;
-                        }
-                        if (arm.won(result)) {
-                            arm.onWon(result);
+                    if (probed.kind === "denied") {
+                        await nap(TERMINAL_CLAIM_CAP_POLL_MS);
+                        continue;
+                    }
+                    if (probed.kind === "row") {
+                        const read = this.classifyClaimLoss(pinnedAskId, probed.current, `yield-probe:${arm.intent}`);
+                        if (settleFromClaimLoss(read))
                             return;
-                        }
-                        await convergeFromDurableState(arm.where);
-                        return;
+                        if (read.kind === "edit-in-flight")
+                            lastLoss = probed.current;
                     }
-                    case "absent":
-                        arm.settleByIntent();
-                        return;
-                    case "edit-in-flight":
-                    case "unreadable":
-                        if (attempt < DURABLE_CONVERGE_BACKOFF_MS.length)
-                            await new Promise((r) => setTimeout(r, DURABLE_CONVERGE_BACKOFF_MS[attempt]).unref?.());
+                    else if (this.terminalClaimsInFlightCount(pinnedAskId) > 0) {
+                        await nap(TERMINAL_CLAIM_CAP_POLL_MS);
                         continue;
-                    default: {
-                        const unreachable = read;
-                        throw new Error(`recoverFromUnknownStore: unknown recovery read ${String(unreachable)}`);
                     }
+                    await nap(backoffAfter);
+                    attempt++;
+                    continue;
+                }
+                const inFlight = arm.claim(Math.min(attempt === 0 ? DURABLE_CALL_TIMEOUT_MS : DURABLE_CONVERGE_READ_TIMEOUT_MS, remainingMs()));
+                if (inFlight === undefined) {
+                    await nap(TERMINAL_CLAIM_CAP_POLL_MS);
+                    continue;
+                }
+                claimsIssued++;
+                let outcome;
+                try {
+                    outcome = await inFlight;
+                }
+                catch (err) {
+                    this.noteStoreError(err, arm.storeLabel);
+                    rejects++;
+                    await nap(backoffAfter);
+                    attempt++;
+                    continue;
+                }
+                if (outcome.claimed) {
+                    arm.onWon(outcome);
+                    return;
                 }
+                arm.onLostTruth?.(outcome.current);
+                const read = this.classifyClaimLoss(pinnedAskId, outcome.current, `claim:${arm.intent}`);
+                if (done) {
+                    broadcastClaimTruth(read);
+                    return;
+                }
+                if (settleFromClaimLoss(read))
+                    return;
+                if (read.kind === "absent") {
+                    arm.settleByIntent();
+                    return;
+                }
+                lastLoss = outcome.current;
+                await nap(backoffAfter);
+                attempt++;
             }
             if (done)
                 return;
@@ -1036,24 +1122,10 @@ export class ToolApprovalCoordinator {
                 settle(false, "expired");
                 return;
             }
-            recordFailOpen(ambiguousCasFailOpenTag(arm.intent), `askId=${pinnedAskId} reads=${DURABLE_CONVERGE_BACKOFF_MS.length + 1}`);
-            arm.settleByIntent();
-        };
-        const resolveLocalOutcome = async (arm) => {
-            let result;
-            try {
-                result = await arm.cas();
-            }
-            catch (err) {
-                this.noteStoreError(err, arm.storeLabel);
-                await recoverFromUnknownStore(arm, err instanceof ApprovalStoreDeadlineError);
-                return;
-            }
-            if (arm.won(result)) {
-                arm.onWon(result);
+            if (lastLoss !== undefined && settleFromClaimLoss(this.classifyClaimLoss(pinnedAskId, lastLoss, `claim-tail:${arm.intent}`)))
                 return;
-            }
-            await convergeFromDurableState(arm.where);
+            recordFailOpen(ambiguousCasFailOpenTag(arm.intent), `askId=${pinnedAskId} attempts=${attempt} claims=${claimsIssued} rejects=${rejects} elapsedMs=${Date.now() - ladderStartedAt}`);
+            arm.settleByIntent();
         };
         const settleParkRouteIfUnsettled = (hostSettledBy) => {
             if (done)
@@ -1072,22 +1144,22 @@ export class ToolApprovalCoordinator {
                 const pinnedBatchId = batchId;
                 await resolveLocalOutcome({
                     intent: "expire",
-                    storeLabel: "expireAsk",
-                    where: "windowExpired",
-                    cas: () => this.withStoreDeadline(store.expireAsk(pinnedAskId, pinnedBatchId), "expireAsk(window)", DURABLE_CALL_TIMEOUT_MS, (late) => {
-                        if (!late.won)
+                    storeLabel: "claimTerminal(window)",
+                    claim: (timeoutMs) => boundedClaim(() => store.claimTerminal(pinnedAskId, pinnedBatchId, "expire"), "claimTerminal(window)", timeoutMs, (late) => {
+                        if (!late.claimed) {
+                            lateClaimLossSettle(late.current, "expire");
                             return;
+                        }
                         this.settleSameAskIdParkRoute(pinnedAskId);
                         this.settleVoidedSiblings(late.voidedSiblings);
-                        this.emitRevokeTo(aliveCtxs, buildRevokeFrame(pinnedBatchId, late.voidedSiblings, "superseded_by_park", Date.now()));
+                        this.emitRevokeTo(aliveCtxs, buildRevokeFrame(pinnedBatchId, late.voidedSiblings, "superseded_by_park", Date.now(), origin.taskId));
                     }),
-                    won: (res) => res.won,
                     onWon: (res) => {
                         windowRouteUnavailable = true;
                         settle(false, "expired");
                         this.settleSameAskIdParkRoute(pinnedAskId);
                         this.settleVoidedSiblings(res.voidedSiblings);
-                        this.emitRevokeTo(aliveCtxs, buildRevokeFrame(pinnedBatchId, res.voidedSiblings, "superseded_by_park", Date.now()));
+                        this.emitRevokeTo(aliveCtxs, buildRevokeFrame(pinnedBatchId, res.voidedSiblings, "superseded_by_park", Date.now(), origin.taskId));
                     },
                     settleByIntent: () => settleParkRouteIfUnsettled(hostSelfReport),
                 });
@@ -1116,24 +1188,31 @@ export class ToolApprovalCoordinator {
             const store = this.askStore;
             const pinnedAskId = askId;
             const pinnedBatchId = batchId;
+            const cancelLostTruth = (current) => {
+                if (current.state !== "VOID")
+                    return;
+                this.recordParkTombstone(wireApprovalId, { kind: "voidBridge", askId: pinnedAskId, batchId: pinnedBatchId, owner: origin.owner, parkedAtMs: Date.now() });
+            };
             await resolveLocalOutcome({
                 intent: "cancel",
-                storeLabel: "transitionAsk(cancel)",
-                where: "runCancel",
-                cas: () => this.withStoreDeadline(store.transitionAsk(pinnedAskId, "STREAM_PENDING", "VOID", { updatedAtMs: Date.now() }), "transitionAsk(cancel)", DURABLE_CALL_TIMEOUT_MS, (lateWon) => {
-                    if (!lateWon)
+                storeLabel: "claimTerminal(cancel)",
+                claim: (timeoutMs) => boundedClaim(() => store.claimTerminal(pinnedAskId, pinnedBatchId, "cancel"), "claimTerminal(cancel)", timeoutMs, (late) => {
+                    if (!late.claimed) {
+                        cancelLostTruth(late.current);
+                        lateClaimLossSettle(late.current, "cancel");
                         return;
+                    }
                     this.settleVoidedSiblings([pinnedAskId]);
                     this.recordParkTombstone(wireApprovalId, { kind: "voidBridge", askId: pinnedAskId, batchId: pinnedBatchId, owner: origin.owner, parkedAtMs: Date.now() });
-                    this.emitRevokeTo(aliveCtxs, buildRevokeFrame(pinnedBatchId, [pinnedAskId], "aborted", Date.now()));
+                    this.emitRevokeTo(aliveCtxs, buildRevokeFrame(pinnedBatchId, [pinnedAskId], "aborted", Date.now(), origin.taskId));
                 }),
-                won: (won) => won,
                 onWon: () => {
                     settle(false, "expired");
                     this.settleVoidedSiblings([pinnedAskId]);
                     this.recordParkTombstone(wireApprovalId, { kind: "voidBridge", askId: pinnedAskId, batchId: pinnedBatchId, owner: origin.owner, parkedAtMs: Date.now() });
-                    this.emitRevokeTo(aliveCtxs, buildRevokeFrame(pinnedBatchId, [pinnedAskId], "aborted", Date.now()));
+                    this.emitRevokeTo(aliveCtxs, buildRevokeFrame(pinnedBatchId, [pinnedAskId], "aborted", Date.now(), origin.taskId));
                 },
+                onLostTruth: cancelLostTruth,
                 settleByIntent: () => settle(false, "expired"),
             });
         };
@@ -1193,6 +1272,18 @@ export class ToolApprovalCoordinator {
             }
             siblings.add(pendingEntry);
         }
+        this.askAudit?.recordAsk({
+            approvalId: wireApprovalId,
+            taskId: origin.taskId,
+            ...(req.sourceTaskId !== undefined ? { sourceTaskId: req.sourceTaskId } : {}),
+            ...(origin.sessionId !== undefined ? { sessionId: origin.sessionId } : {}),
+            owner: origin.owner,
+            toolName: req.toolName,
+            toolCallId: req.toolCallId,
+            legTracked: !child && aliveCtxs.some((c) => c.taskId === origin.taskId),
+            expiresAtMs: persistedExpiresAtMs,
+            mintedAtMs: Date.now(),
+        });
         const cardFrame = askId !== undefined && cardForFrame !== undefined
             ? buildApprovalRequestFrame({ askId, taskId: origin.taskId, approvalId: wireApprovalId, card: cardForFrame, expiresAtMs: persistedExpiresAtMs, nowMs: Date.now() })
             : undefined;
@@ -1239,15 +1330,15 @@ export class ToolApprovalCoordinator {
                     };
                     await resolveLocalOutcome({
                         intent: "unreachable",
-                        storeLabel: "expireAsk(emit-failed)",
-                        where: "emitFailed",
-                        cas: () => this.withStoreDeadline(store.expireAsk(pinnedAskId, pinnedBatchId), "expireAsk(emit-failed)", DURABLE_CALL_TIMEOUT_MS, (late) => {
-                            if (!late.won)
+                        storeLabel: "claimTerminal(emit-failed)",
+                        claim: (timeoutMs) => boundedClaim(() => store.claimTerminal(pinnedAskId, pinnedBatchId, "expire"), "claimTerminal(emit-failed)", timeoutMs, (late) => {
+                            if (!late.claimed) {
+                                lateClaimLossSettle(late.current, "unreachable");
                                 return;
+                            }
                             this.settleSameAskIdParkRoute(pinnedAskId);
                             this.settleVoidedSiblings(late.voidedSiblings);
                         }),
-                        won: (res) => res.won,
                         onWon: (res) => {
                             settleUnreachable();
                             this.settleSameAskIdParkRoute(pinnedAskId);

package/dist/trace/ledger-events.d.ts

@@ -38,6 +38,15 @@ export type LedgerEventType = "reasoning" | "text" | "tool_start" | "tool_end" |
  | "elicitation" | "elicitation_complete" | "question" | "question_complete" | "tool_approval" | "tool_approval_complete"
 /** [ref] §4.3 新协议的呈卡帧(与上面两只 tool_approval 帧同一条投递面)。 */
  | "approval_request"
+/**
+ * [ref]([ref]):批级撤卡帧在 **bg/resume 两条 durable 腿**的账本落行(与呈卡帧同口
+ * `append(type, rest)`,seq 由腿自己的 ledger 链步分配)。此前成文「reaper/收敛器无 seq 可分配故
+ * live-only」只对**调用点**成立,不对 ctx 的投递口成立——帧经 `emitRevokeTo` 交给各 ctx 的
+ * `emitRevoke`,durable 腿的那只钩子自己就是账本写口。sync 腿维持 live-only(行为零变,
+ * `routes/tasks.ts` 装配点注)。重放语义:同一账本里卡帧(`approval_request`)在前、撤帧在后,
+ * 全量重读恒同序 ⇒ 幂等诚实;不投影成 trace 2.3 帧(`LEDGER_TYPES_NOT_PROJECTED` 登记)。
+ */
+ | "approval_revoke"
 /** 异步 workflow 完成的入箱 drain(`emitPendingWorkflowCompletions` 两个字面型之一)。 */
  | "workflow_complete"
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "7.54.0",
+  "version": "7.55.0",
   "description": "Sema Server — the server/API implementation layer for Sema, wiring core, registry, model providers, and cloud agent execution. Built on @sema-agent/core.",
   "type": "module",
   "license": "BUSL-1.1",
@@ -69,7 +69,7 @@
     "sharp": "^0.35.3"
   },
   "devDependencies": {
-    "@sema-agent/sdk": "7.4.0",
+    "@sema-agent/sdk": "8.1.0",
     "@types/libsodium-wrappers": "^0.7.14",
     "@types/node": "22.10.2",
     "@types/pg": "^8.20.0",