@sema-agent/server 7.55.0 → 7.56.0

package/dist/rules-consent.js

@@ -230,27 +230,6 @@ export function createRuleConsentLane(stores, opts) {
     const monotonic = opts?.monotonic ?? (() => performance.now());
     const sleep = opts?.sleep ?? (async (ms) => new Promise((resolve) => setTimeout(resolve, ms)));
     const localImportLogger = createLogger();
-    const anchors = new Map();
-    const ANCHOR_CAP = 4096;
-    const pruneAnchors = (nowMono) => {
-        for (const [id, a] of anchors) {
-            if (nowMono - a.mintedAtMono > ticketTtlMs)
-                anchors.delete(id);
-        }
-        if (anchors.size <= ANCHOR_CAP)
-            return;
-        const excess = anchors.size - ANCHOR_CAP;
-        let dropped = 0;
-        for (const id of anchors.keys()) {
-            if (dropped++ >= excess)
-                break;
-            anchors.delete(id);
-        }
-    };
-    const decisionClock = (ticketId) => {
-        const a = anchors.get(ticketId);
-        return a === undefined ? undefined : { decisionNowMs: Math.ceil(a.mintedAtWall + (monotonic() - a.mintedAtMono)) };
-    };
     return {
         async persistCardRule(input) {
             let prepared;
@@ -360,14 +339,10 @@ export function createRuleConsentLane(stores, opts) {
                 }
                 return { ok: false, reason: "too-many-candidates", candidates: preview.candidates.length };
             }
-            const mintedAtMono = monotonic();
             const minted = await stores.tickets.mint({ ticketId: newTicketId(), principal, approvalId, purpose: "cc-import", candidates: preview.candidates, ttlMs: ticketTtlMs });
-            pruneAnchors(mintedAtMono);
-            anchors.set(minted.ticketId, { mintedAtWall: minted.expiresAtMs - ticketTtlMs, mintedAtMono });
             return { ok: true, preview, ticket: minted.ticketId, expiresAtMs: minted.expiresAtMs };
         },
         async redeemImport(principal, ticket) {
-            const clock = decisionClock(ticket);
             const consumeOutcomeAfterThrow = async (err) => {
                 localImportLogger.warn("cc_import_claim_write_failed", {
                     err: err instanceof Error ? err.message : String(err),
@@ -398,7 +373,7 @@ export function createRuleConsentLane(stores, opts) {
             };
             let consumed;
             try {
-                consumed = await stores.tickets.consume(ticket, principal, "cc-import", clock);
+                consumed = await stores.tickets.consume(ticket, principal, "cc-import");
             }
             catch (err) {
                 return await consumeOutcomeAfterThrow(err);
@@ -407,7 +382,7 @@ export function createRuleConsentLane(stores, opts) {
                 return { ok: false, reason: "ticket-unusable", detail: consumed.reason };
             const releaseClaim = async () => {
                 try {
-                    return await stores.tickets.release(ticket, principal, consumed.claimId, RULE_IMPORT_RETRY_AFTER_SEC * 1000, decisionClock(ticket));
+                    return await stores.tickets.release(ticket, principal, consumed.claimId, RULE_IMPORT_RETRY_AFTER_SEC * 1000);
                 }
                 catch (err) {
                     recordFailOpen("server.rules.ticket-claim-release-failed", err instanceof Error ? err.message : String(err));
@@ -496,10 +471,7 @@ export function createRuleConsentLane(stores, opts) {
             }
             if (approvalId === undefined)
                 return { ok: true, preview: { members } };
-            const mintedAtMono = monotonic();
             const minted = await stores.tickets.mint({ ticketId: newTicketId(), principal, approvalId, purpose: "local-import", candidates: preview.candidates, ttlMs: ticketTtlMs });
-            pruneAnchors(mintedAtMono);
-            anchors.set(minted.ticketId, { mintedAtWall: minted.expiresAtMs - ticketTtlMs, mintedAtMono });
             return { ok: true, preview: { members }, ticket: minted.ticketId, expiresAtMs: minted.expiresAtMs };
         },
         async redeemLocalImport(principal, ticket) {
@@ -530,7 +502,7 @@ export function createRuleConsentLane(stores, opts) {
             const driveAndSettle = async (approvalId, payloadHash, claimId) => {
                 const tryRelease = async () => {
                     try {
-                        return await stores.tickets.release(ticket, principal, claimId, RULE_IMPORT_RETRY_AFTER_SEC * 1000, decisionClock(ticket));
+                        return await stores.tickets.release(ticket, principal, claimId, RULE_IMPORT_RETRY_AFTER_SEC * 1000);
                     }
                     catch (err) {
                         recordFailOpen("server.rules.ticket-claim-release-failed", err instanceof Error ? err.message : String(err));
@@ -638,7 +610,7 @@ export function createRuleConsentLane(stores, opts) {
             };
             let consumed;
             try {
-                consumed = await stores.tickets.consume(ticket, principal, "local-import", decisionClock(ticket));
+                consumed = await stores.tickets.consume(ticket, principal, "local-import");
             }
             catch (err) {
                 return await claimOutcomeAfterThrow(err, "consume");
@@ -660,7 +632,7 @@ export function createRuleConsentLane(stores, opts) {
                     case "minted": {
                         let again;
                         try {
-                            again = await stores.tickets.consume(ticket, principal, "local-import", decisionClock(ticket));
+                            again = await stores.tickets.consume(ticket, principal, "local-import");
                         }
                         catch (err) {
                             return await claimOutcomeAfterThrow(err, "consume");

package/dist/runtime-caps-resolver.js

@@ -31,7 +31,7 @@ export function toCoreRuntimeCaps(ent) {
         return undefined;
     const autoMode = ent.autoMode;
     const badCap = (v) => v !== undefined && typeof v !== "boolean";
-    if (badCap(ent.allowWorkflows) || badCap(ent.forceDurableGate) || badCap(ent.allowFork) || badCap(ent.allowObservers) || badCap(autoMode)) {
+    if (badCap(ent.allowWorkflows) || badCap(ent.forceDurableGate) || badCap(ent.allowFork) || badCap(ent.allowObservers) || badCap(autoMode) || badCap(ent.allowMemoryOptOut)) {
         throw new Error("runtimeCaps from center carries a non-boolean cap (contract breach — fail closed)");
     }
     const caps = {};
@@ -45,6 +45,8 @@ export function toCoreRuntimeCaps(ent) {
         caps.allowObservers = ent.allowObservers;
     if (typeof autoMode === "boolean")
         caps.autoMode = autoMode;
+    if (typeof ent.allowMemoryOptOut === "boolean")
+        caps.allowMemoryOptOut = ent.allowMemoryOptOut;
     return Object.keys(caps).length ? caps : undefined;
 }
 export function centerEntitlementSourceWired(config) {

package/dist/security.d.ts

@@ -15,6 +15,13 @@ export interface SessionListItem {
     lastStatus: string;
     /** K-5c (shell §K): the latest run's task_id — the shell's one-hop live-tail re-attach anchor on resume. */
     lastRunId: string | null;
+    /** [ref]([ref]/[ref]):the LATEST run's **engine run id**(`TaskResult.runId`)when known —— OMIT-when-absent,
+     *  恒不铸 null。runs-ledger listers 从 latest run 的终局 `result` JSON 提取(⇒ 在跑 latest 键诚实缺席);
+     *  local lister 走 `noteTaskRun` 席实时记录(⇒ 在跑也在场)——两面缺席集合不完全相等,读法一致:
+     *  缺席 = 「此行无已知 engine runId」,禁读成其它含义。⚠️ 与 `lastRunId`(= latest run 的 **task_id**)
+     *  是两条身份轴,命名对齐 core `SessionStoreSummary.lastTaskRunId`。wire:additive 键零投影透传
+     *  (sessions-list.ts);sema-sdk spec `SessionSummary` 闭集候 SDK 半场开键([ref]/.82 班车)。 */
+    lastTaskRunId?: string;
     /** Auto-generated session title (null = untitled / lister face has no session_meta). */
     title: string | null;
 }

package/dist/tool-approval.d.ts

@@ -22,10 +22,10 @@ export declare const APPROVAL_GATE_KINDS_SQL_IN: string;
  * 因此续跑」。反面(真被消费)不铸键 —— additive 只记真,与 `updatedInputForwarded`/`decisionNote`
  * 的先例逐字同族。**缺席禁读作「有消费者」的证明**:老版本 server 从不发这个键。
  *
- * 成因三形([ref] 复审件3 补第三形):①持有悬挂 promise 的是**另一个副本**;②本副本重启后本地窗已空;
- * ③**弃单墓碑守卫把素批准翻成 park**({@link ToolApprovalCoordinator.guardRowDerivedApprove}:本地腿
- * 在场,但没有一条把这次 approve 当**放行**消费 —— 它们全部收成 park,人须经 durable 门再兑)。
- * 三形的处置同一句:壳读 run 面判续跑没有,绝不把 200 无键当成「run 已续跑」的证明。
+ * 成因两形([ref] 起;[ref] 复审件3 曾补的第三形 = 弃单墓碑守卫翻 park,随守卫整删退役。进程内仍可
+ * 短暂出现「腿在场而零交付」:编辑在飞让路 —— 标记放开后的下一拍按行兑现):①持有悬挂 promise 的是
+ * **另一个副本**;②本副本重启后本地窗已空。
+ * 两形的处置同一句:壳读 run 面判续跑没有,绝不把 200 无键当成「run 已续跑」的证明。
  *
  * 为什么不是 409/410(施工时的二选一,裁定写在这里):409/410 说的是「你的请求没有生效」,而这次决议
  * **确实生效了**(行是 DECIDED,幂等回放读得到、审计面记得住)——把它渲成错误会让壳把一次成功的
@@ -323,6 +323,10 @@ export interface LivePendingRow {
      *  子代 ask)上恒等成立。缺席 = 顶层 ask。`fromSubagent` 保留不动(byte-compat:先于本键的消费方仍按
      *  它判别)。 */
     originTaskId?: string;
+    /** [ref]([ref]②):内容问句分型 —— `"content_ask"` 当 `toolName` 为 AskUserQuestion(词属主
+     *  `approval-content-kind.ts`,与 durable 两读面 / core summarize 面同词,OMIT 契约同族)。
+     *  缺席 = 普通工具 ask。展示/分诊分型用,永不参与决议路由。 */
+    contentKind?: "content_ask";
 }
 export interface ToolApprovalRunContext {
     taskId: string;
@@ -670,10 +674,6 @@ export declare class ToolApprovalCoordinator {
     /** [ref] + codex R3-[critical]:askId → **此刻正带着 `updatedInput` 决它的请求数**(见
      *  {@link markEditedDecisionInFlight} 顶注)。只在 `decideAsk` 那一次调用期间非空,故天然有界。 */
     private readonly editedDecisionsInFlight;
-    /** [ref] + codex R6-[critical]:askId → **弃单墓碑**到期时刻。看门狗放弃一枚在飞编辑标记时落一条,
-     *  此后行派生的 approve 对这只 ask 改走 park 路由(理由见 {@link notifyExternalDecision} 里那段)。
-     *  有界两道:条目自带 TTL(惰性过期)+ 表大小 FIFO 上限,同 park 墓碑表的纪律。 */
-    private readonly abandonedEditedDecisions;
     /** [ref] 车2(D5 一次性 warn 节流):同实例只报第一次,后续只计数(避免 store 抖动期间刷屏)。 */
     private storeErrorWarned;
     private storeErrorTally;
@@ -911,8 +911,7 @@ export declare class ToolApprovalCoordinator {
      * 争终局与读真相并成店的一次原子 claim,分类器只剩纯函数半场。[ref](行派生 approve 丢编辑)已随
      * [ref] 落列收口:`approved` 臂带行上的 `updatedInput`。
      *
-     * 行派生 approve 的两道守卫**在这里**施加(五处消费一份判据,见 {@link guardRowDerivedApprove}):
-     *  · 弃单墓碑在场 ⇒ `parked`(park 路由,可逆可再批 —— 绝不把一个证不出载荷的放行交出去);
+     * 行派生 approve 的守卫只剩一道**在这里**施加([ref]:弃单墓碑守卫随 [ref] 落列整删,见文件头 🪦 注):
      *  · 编辑在飞 ⇒ `edit-in-flight`(codex R4-[critical] 同族口:载荷还在别人手里的那一拍按行结算 = 用裸
      *    `true` 抢在它前面;持有者随后必定自己结算)。
      */
@@ -1224,15 +1223,6 @@ export declare class ToolApprovalCoordinator {
         backlog: number;
         truncated: boolean;
     }>;
-    /**
-     * [ref](案A)+ codex [critical] 的**前置门读口**:本副本对这条持久 askId 还有几条**未结算**的活体登记。
-     *
-     * 唯一消费者 = durable 回决口(`routes/runs.ts`)在 CAS **之前**判「这次带来的 `updatedInput` 交得出去
-     * 吗」—— 交不出去就响亮拒,绝不静默把编辑降级成不带编辑的批准(判据与理由全文在那个调用点)。
-     * 返回 0 的两种成因(**刻意不分**):等待的 promise 在**别的副本**,或那条 run 已经死了(重启后本地窗空)。
-     * 两者的处置相同(这次编辑在这里都落不了地),而分辨它们需要读 run 面 —— 那不是本口能回答的问题。
-     */
-    liveConsumerCount(askId: string): number;
     /**
      * 🔴 [ref] + codex R3-[critical](真缺陷,红先复现器在 `test/case-a-reachability-queue.test.ts` 同名格)
      * —— **带编辑的决议在飞期间,观察者不结算**。
@@ -1260,48 +1250,10 @@ export declare class ToolApprovalCoordinator {
     editedDecisionInFlightCount(askId: string): number;
     /** {@link markEditedDecisionInFlight} 的读口:此刻有没有**别的**请求正带着编辑决这只 ask。 */
     editedDecisionInFlight(askId: string): boolean;
-    /**
-     * 弃单墓碑的读口(**惰性过期**:读到过期即删,不另起定时器 —— 同 park 墓碑表的姿势)。
-     * 在场 = 这只 ask 曾有一次带编辑的决议在飞而看门狗放弃了它 ⇒ **行派生**的 approve 一律改走 park 路由。
-     *
-     * 🔴 **过期/逐出必须 fail-closed**(codex R7-[high],验真后采纳):首版是「到点就删」——而它保护的是
-     * 一条**仍然挂着**的本地等待腿。店退化到十分钟以上、或并发弃单超过表帽时,墓碑先消失、腿还在,下一次
-     * 行派生 approve 照样把原始命令放出去,正好复活它要防的那件事。判据改成:**丢墓碑之前先把它保护的
-     * 消费者收掉**(park 路由,可逆可再批)。收完之后再删就是安全的 —— 没有腿可被误放行了。
-     */
-    private abandonedEditedDecisionPending;
-    /**
-     * 🔴 **行派生 approve 的统一守卫**(codex R7-[critical],验真后修)。
-     *
-     * R6 把弃单墓碑的兑现点收在 {@link notifyExternalDecision} 上,并自称「公共咽喉」—— 那句话**不成立**:
-     * 树上还有三处**直接** `settle(true, …)` / 直接把 `true` 交回 core 的行派生回放(`convergeFromDurableState`
-     * 的收敛臂、`ensureAsk` 幂等命中终局行的回放、窗到期报错臂的 `readDecidedForRecovery` —— [ref] 起前者与
-     * 后者合并成 `readRowForRecovery` 一个读口、三臂共用;[ref] 起读口撤销,同一份判据长在 claim 败方读数的
-     * 分类器 `classifyClaimLoss` 里),它们跳过那个口。于是弃单之后从这三条路上仍能放出原始命令。
-     *
-     * 收口形 = **一个判据函数、五处消费**(上面三处 + 轮询 + HTTP 观察者):把「行说 approve」这件事
-     * 在弃单墓碑在场时翻译成 `"unavailable"`(park 路由,可逆可再批),其余取值逐字透传。
-     * 判据只认**不带编辑的行派生**放行(裸 `true`)—— 人的当次决议带着 `updatedInput` 走的是另一条路,不经
-     * 本函数;[ref] 之后行上带编辑的 approve 回放出来是对象臂 `{allow:true, updatedInput}`,载荷**在行上**,
-     * 墓碑要护的「证不出载荷」这件事对它不成立,同样原样透传。
-     * ⚠️ 既有边界如实记([ref] 随批复核):列在之后,一只 ask 的决议**要么**带编辑落列(回放恒对象臂,本
-     * 守卫永不命中)**要么**从没带过编辑(从没设过在飞标记,永无墓碑)⇒ 本守卫在新行上结构上不再可达,
-     * 留着只为老进程/老行的并存窗与既有判据格;拆除是独立件([ref] 登记),不搭本批。
-     */
-    private guardRowDerivedApprove;
-    /** 丢一枚弃单墓碑的**唯一**口(过期 / 容量逐出共用):先把它还在保护的本地消费者按 park 路由收掉,
-     *  再删表项 —— 顺序是硬的(先删表再收人 = 中间那一瞬正是可被误放行的窗口)。 */
-    private dropAbandonedEditTombstone;
-    /** 判据钩子:把「看门狗那一拍」显式地跑一次(留弃单墓碑 + 让在飞标记归零)。
-     *  存在理由 = 那条臂的真实触发要等 {@link EDITED_DECISION_MARK_CAP_MS} 的墙钟,而本仓禁固定睡眠钉
-     *  (fixed-sleep 棘轮);把**语义**开一个口比让判据去睡 10 秒诚实得多。生产路径不调它。 */
+    /** 判据钩子:把「看门狗那一拍」显式地跑一次(= 在飞标记被放弃归零;[ref] 起看门狗不再铸弃单墓碑,
+     *  本钩子随之只剩这一半)。存在理由 = 那条臂的真实触发要等 {@link EDITED_DECISION_MARK_CAP_MS} 的
+     *  墙钟,而本仓禁固定睡眠钉(fixed-sleep 棘轮)。生产路径不调它。 */
     expireEditedDecisionMarkForTest(askId: string): void;
-    /** 判据钩子:把一枚弃单墓碑**拨到已过期**并当场走它的丢弃路(= 真实 TTL 到点那一拍的语义)。
-     *  同上理由:真触发要等 {@link ABANDONED_EDIT_TOMBSTONE_TTL_MS} 的墙钟。生产路径不调它。 */
-    forceAbandonedEditTombstoneExpiryForTest(askId: string): void;
-    /** 判据钩子:把一枚弃单墓碑的到期时刻**改写**成给定值(不触发惰性过期口本身)。用来构造
-     *  「墓碑已过期、但还没有任何人来读过它」这一拍 —— 那正是「触发过期的那次调用还护不护」的判据点。 */
-    setAbandonedEditTombstoneDeadlineForTest(askId: string, atMs: number): void;
     /** Test/observability hooks. */
     pendingCount(): number;
     /** [ref]:当前挂着的**悬挂**条目数(零投递集合铸的那一类)——运维/判据读它证「悬挂队列有多长」。 */

package/dist/tool-approval.js

@@ -1,3 +1,4 @@
+import { contentKindOf } from "./approval-content-kind.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { uuidv7, MAX_RULE_TEXT_CHARS } from "@sema-agent/core";
 import { precheckCardRuleText } from "./rules-consent.js";
@@ -22,8 +23,6 @@ const DEFAULT_UNREACHED_ASK_TTL_MS = 60 * 60_000;
 const SUSPENDED_POLL_MAX_PER_TICK = 64;
 const SUSPENDED_POLL_BUDGET_MS = 5_000;
 const EDITED_DECISION_MARK_CAP_MS = 10_000;
-const ABANDONED_EDIT_TOMBSTONE_TTL_MS = 10 * 60_000;
-const ABANDONED_EDIT_TOMBSTONE_MAX = 256;
 const DEFAULT_WINDOW_MARGIN_MS = 10_000;
 const MAX_ALLOW_SESSIONS = 4096;
 const DEFAULT_ADMIT_MAX_PER_TASK = 32;
@@ -269,7 +268,6 @@ export class ToolApprovalCoordinator {
     admitByOwner = new Map();
     suspendedPollOffset = 0;
     editedDecisionsInFlight = new Map();
-    abandonedEditedDecisions = new Map();
     storeErrorWarned = false;
     storeErrorTally = 0;
     governanceAskMarks;
@@ -504,10 +502,10 @@ export class ToolApprovalCoordinator {
             return { kind: "none" };
         return { kind: "row", current: projectAskTerminalClaimTruth(row) };
     }
-    classifyClaimLoss(askId, current, where) {
+    classifyClaimLoss(askId, current, _where) {
         if (current.state === "absent")
             return { kind: "absent" };
-        const replayed = settleArgsOf(this.guardRowDerivedApprove(askId, replayTerminalAskRow(current), where));
+        const replayed = settleArgsOf(replayTerminalAskRow(current));
         if (replayed === "unavailable")
             return { kind: "parked" };
         if (!replayed.allowed)
@@ -608,10 +606,6 @@ export class ToolApprovalCoordinator {
         const entries = this.pendingByAskId.get(askId);
         if (!entries)
             return { settled: 0 };
-        if (allowed && updatedInput === undefined) {
-            if (this.guardRowDerivedApprove(askId, true, "notify-external-decision") === "unavailable")
-                return { settled: 0 };
-        }
         let settled = 0;
         for (const entry of [...entries]) {
             entry.settle(allowed, allowed ? "allowed" : "denied", updatedInput);
@@ -820,7 +814,7 @@ export class ToolApprovalCoordinator {
                 });
                 if (existingOrCreated.row.state !== "STREAM_PENDING") {
                     releaseAdmission();
-                    const replayed = this.guardRowDerivedApprove(askId, replayTerminalAskRow(existingOrCreated.row), "ensure-ask-idempotent-replay");
+                    const replayed = replayTerminalAskRow(existingOrCreated.row);
                     return replayed === "unavailable" ? this.unattendedOutcome() : replayed;
                 }
                 const persistedEnvelope = ApprovalCardEnvelopeSchema.safeParse(existingOrCreated.row.cardJson);
@@ -1859,6 +1853,7 @@ export class ToolApprovalCoordinator {
         for (const [id, e] of this.pending) {
             if (scope !== undefined && e.owner !== scope)
                 continue;
+            const contentKind = contentKindOf(e.toolName);
             rows.push({
                 approvalId: id,
                 toolName: e.toolName,
@@ -1868,6 +1863,7 @@ export class ToolApprovalCoordinator {
                 ...(e.requiresRealApproval ? { requiresRealApproval: true } : {}),
                 ...(e.governanceForced ? { governanceForced: true } : {}),
                 ...(e.originTaskId !== undefined ? { fromSubagent: true, originTaskId: e.originTaskId } : {}),
+                ...(contentKind !== undefined ? { contentKind } : {}),
             });
         }
         return rows;
@@ -1932,13 +1928,6 @@ export class ToolApprovalCoordinator {
         }
         return { polled, settled, backlog, truncated };
     }
-    liveConsumerCount(askId) {
-        let n = 0;
-        for (const e of this.pendingByAskId.get(askId) ?? [])
-            if (e.settledOutcome === undefined)
-                n++;
-        return n;
-    }
     markEditedDecisionInFlight(askId) {
         this.editedDecisionsInFlight.set(askId, (this.editedDecisionsInFlight.get(askId) ?? 0) + 1);
         let released = false;
@@ -1957,12 +1946,6 @@ export class ToolApprovalCoordinator {
             if (released)
                 return;
             defaultLogger.warn("approval_edited_decision_mark_expired", { askId, capMs: EDITED_DECISION_MARK_CAP_MS });
-            this.abandonedEditedDecisions.set(askId, Date.now() + ABANDONED_EDIT_TOMBSTONE_TTL_MS);
-            if (this.abandonedEditedDecisions.size > ABANDONED_EDIT_TOMBSTONE_MAX) {
-                const oldest = this.abandonedEditedDecisions.keys().next();
-                if (!oldest.done)
-                    this.dropAbandonedEditTombstone(oldest.value, "capacity");
-            }
             drop();
         }, EDITED_DECISION_MARK_CAP_MS);
         watchdog.unref?.();
@@ -1974,47 +1957,9 @@ export class ToolApprovalCoordinator {
     editedDecisionInFlight(askId) {
         return (this.editedDecisionsInFlight.get(askId) ?? 0) > 0;
     }
-    abandonedEditedDecisionPending(askId) {
-        const until = this.abandonedEditedDecisions.get(askId);
-        if (until === undefined)
-            return false;
-        if (Date.now() > until) {
-            this.dropAbandonedEditTombstone(askId, "ttl");
-            return true;
-        }
-        return true;
-    }
-    guardRowDerivedApprove(askId, outcome, where) {
-        if (outcome !== true || askId === undefined)
-            return outcome;
-        if (!this.abandonedEditedDecisionPending(askId))
-            return outcome;
-        defaultLogger.warn("approval_row_derived_approve_parked_after_abandoned_edit", { askId, where });
-        this.settleSameAskIdParkRoute(askId);
-        return "unavailable";
-    }
-    dropAbandonedEditTombstone(askId, why) {
-        const stillWaiting = this.liveConsumerCount(askId);
-        if (stillWaiting > 0) {
-            defaultLogger.warn("approval_abandoned_edit_tombstone_dropped_parking_consumers", { askId, why, parked: stillWaiting });
-            this.settleSameAskIdParkRoute(askId);
-        }
-        this.abandonedEditedDecisions.delete(askId);
-    }
     expireEditedDecisionMarkForTest(askId) {
-        this.abandonedEditedDecisions.set(askId, Date.now() + ABANDONED_EDIT_TOMBSTONE_TTL_MS);
         this.editedDecisionsInFlight.delete(askId);
     }
-    forceAbandonedEditTombstoneExpiryForTest(askId) {
-        if (!this.abandonedEditedDecisions.has(askId))
-            return;
-        this.abandonedEditedDecisions.set(askId, Date.now() - 1);
-        this.abandonedEditedDecisionPending(askId);
-    }
-    setAbandonedEditTombstoneDeadlineForTest(askId, atMs) {
-        if (this.abandonedEditedDecisions.has(askId))
-            this.abandonedEditedDecisions.set(askId, atMs);
-    }
     pendingCount() {
         return this.pending.size;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "7.55.0",
+  "version": "7.56.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",
@@ -55,7 +55,7 @@
   },
   "dependencies": {
     "@sema-agent/core": "7.1.0",
-    "@sema-agent/settings-schema": "1.3.0",
+    "@sema-agent/settings-schema": "1.4.0",
     "e2b": "^2.28.0",
     "libsodium-wrappers": "^0.8.4",
     "mysql2": "^3.22.4",

package/skills/find-skills.md

@@ -141,7 +141,7 @@ npx skills init my-xyz-skill
 ```
 
 <!--
-TODO (blackboard [832], clay): add our own first-party skill sources here -
+TODO (clay): add our own first-party skill sources here -
 sema-registry / config-center - as a discovery+install lane alongside the open
 skills.sh ecosystem. Not every deployment ships a config-center, so the section
 must probe availability first and fall back to the public ecosystem cleanly.

package/skills/loop.md

@@ -35,7 +35,7 @@ Then briefly confirm what's scheduled (id, human cadence, how to cancel with `Cr
 With no interval, run one iteration of the task now, then call `ScheduleWakeup` to schedule when you resume:
 
 - `delaySeconds`: how long to sleep (runtime clamps to [60, 3600]).
-- `reason`: one short, specific sentence ("watching CI run #123" beats "waiting") — shown to the user and telemetry.
+- `reason`: one short, specific sentence ("watching CI run #4521" beats "waiting") — shown to the user and telemetry.
 - `prompt`: the same /loop input verbatim, so the next firing re-enters this skill and continues the loop. For an autonomous loop with no user prompt, pass the literal sentinel `<<autonomous-loop-dynamic>>` (never the CronCreate-mode `<<autonomous-loop>>` sentinel — ScheduleWakeup always uses the `-dynamic` variant).
 - To END the loop: call `ScheduleWakeup` with `stop: true` and omit every other field — the loop ends immediately and no further wakeups fire.