@sema-agent/server 1.323.0 → 2.0.0

package/dist/http/idempotency.d.ts

@@ -1,13 +1,44 @@
+/**
+ * In-memory, TTL'd dedup cache keyed by an opaque string (an Idempotency-Key).
+ *
+ * - `run(key, produce, shouldCache?)` invokes `produce` at most once per key — concurrent and retried calls
+ *   with the same key await the same promise — and retains a CACHEABLE resolution for `ttlMs` so a later retry
+ *   replays it. A rejection (a thrown error billed nothing) or a caller-marked un-cacheable resolution (e.g. a
+ *   transient 409) is evicted so a genuine retry re-runs.
+ * - `peek(key)` returns the cached (in-flight or settled) promise without producing — letting a caller
+ *   short-circuit a retry BEFORE side gates (rate/quota), so the retry gets the same response, not a fresh 429.
+ *   An SSE stream wraps its live run in `run()` so the in-flight promise is stored too; a retry then peeks it.
+ *
+ * Per-entry TTL is enforced on access (O(1)); abandoned keys are reclaimed by a sweep that runs only once the
+ * map grows past a threshold (no O(n) scan on the hot path). Single-threaded event-loop semantics: each HTTP
+ * request is its own task, so there is no get→set race within a tick.
+ *
+ * (Caller context: the sema-registry review gateway mints/echoes the Idempotency-Key and routes a given key to
+ * the same worker, so this PER-POD cache is the worker-side backstop against a retried submission re-running —
+ * and re-billing. Cross-pod / cross-restart exactly-once needs store-backing; the durable async /v1/runs path
+ * is the alternative for long tasks.)
+ */
 export declare class IdempotencyCache<T> {
     private readonly ttlMs;
     private readonly sweepThreshold;
     private readonly entries;
     constructor(ttlMs?: number, sweepThreshold?: number);
+    /** Live (un-expired) cached promise for a key, or undefined — without producing. */
     peek(key: string): Promise<T> | undefined;
     run(key: string | undefined, produce: () => Promise<T>, shouldCache?: (value: T) => boolean): Promise<T>;
     get size(): number;
+    /** Return the cached promise if present AND within the TTL; drop it and return undefined if expired. */
     private live;
+    /** Reclaim expired entries only once the map is large — avoids an O(n) scan on every call (council). */
     private maybeSweep;
 }
+/**
+ * Namespace an Idempotency-Key by the authenticated identity (BL-3). The dedup cache is one per process; keying
+ * it on the RAW client header let a different tenant (or anonymous caller) replaying the same key receive the
+ * FIRST caller's response and skip the rate/quota gates. Folding the credential-derived `source` + the
+ * `principal` into the key scopes a replay to the SAME caller only — cross-tenant collisions become cache
+ * misses (re-run, correctly attributed). `\x1f` (unit separator) can't occur in an HTTP header value, so the
+ * three fields can't be confused. undefined raw key → undefined (no dedup, unchanged).
+ */
 export declare function scopedIdempotencyKey(raw: string | undefined, source: string | null, principal: string | undefined): string | undefined;
 //# sourceMappingURL=idempotency.d.ts.map

package/dist/http/idempotency.js

@@ -1,3 +1,23 @@
+/**
+ * In-memory, TTL'd dedup cache keyed by an opaque string (an Idempotency-Key).
+ *
+ * - `run(key, produce, shouldCache?)` invokes `produce` at most once per key — concurrent and retried calls
+ *   with the same key await the same promise — and retains a CACHEABLE resolution for `ttlMs` so a later retry
+ *   replays it. A rejection (a thrown error billed nothing) or a caller-marked un-cacheable resolution (e.g. a
+ *   transient 409) is evicted so a genuine retry re-runs.
+ * - `peek(key)` returns the cached (in-flight or settled) promise without producing — letting a caller
+ *   short-circuit a retry BEFORE side gates (rate/quota), so the retry gets the same response, not a fresh 429.
+ *   An SSE stream wraps its live run in `run()` so the in-flight promise is stored too; a retry then peeks it.
+ *
+ * Per-entry TTL is enforced on access (O(1)); abandoned keys are reclaimed by a sweep that runs only once the
+ * map grows past a threshold (no O(n) scan on the hot path). Single-threaded event-loop semantics: each HTTP
+ * request is its own task, so there is no get→set race within a tick.
+ *
+ * (Caller context: the sema-registry review gateway mints/echoes the Idempotency-Key and routes a given key to
+ * the same worker, so this PER-POD cache is the worker-side backstop against a retried submission re-running —
+ * and re-billing. Cross-pod / cross-restart exactly-once needs store-backing; the durable async /v1/runs path
+ * is the alternative for long tasks.)
+ */
 export class IdempotencyCache {
     ttlMs;
     sweepThreshold;
@@ -6,6 +26,7 @@ export class IdempotencyCache {
         this.ttlMs = ttlMs;
         this.sweepThreshold = sweepThreshold;
     }
+    /** Live (un-expired) cached promise for a key, or undefined — without producing. */
     peek(key) {
         return this.live(key);
     }
@@ -18,6 +39,9 @@ export class IdempotencyCache {
             return hit;
         const promise = produce();
         this.entries.set(key, { at: Date.now(), promise });
+        // Evict on rejection (retry must re-run) and on a caller-marked un-cacheable resolution; keep only a
+        // cacheable success for the TTL. Handlers also avert an unhandled-rejection on the cached copy; the returned
+        // promise is the same object the caller awaits, so errors still surface to the caller.
         promise.then((value) => {
             if (!shouldCache(value))
                 this.entries.delete(key);
@@ -27,6 +51,7 @@ export class IdempotencyCache {
     get size() {
         return this.entries.size;
     }
+    /** Return the cached promise if present AND within the TTL; drop it and return undefined if expired. */
     live(key) {
         const hit = this.entries.get(key);
         if (!hit)
@@ -37,6 +62,7 @@ export class IdempotencyCache {
         }
         return hit.promise;
     }
+    /** Reclaim expired entries only once the map is large — avoids an O(n) scan on every call (council). */
     maybeSweep() {
         if (this.entries.size < this.sweepThreshold)
             return;
@@ -46,6 +72,14 @@ export class IdempotencyCache {
                 this.entries.delete(k);
     }
 }
+/**
+ * Namespace an Idempotency-Key by the authenticated identity (BL-3). The dedup cache is one per process; keying
+ * it on the RAW client header let a different tenant (or anonymous caller) replaying the same key receive the
+ * FIRST caller's response and skip the rate/quota gates. Folding the credential-derived `source` + the
+ * `principal` into the key scopes a replay to the SAME caller only — cross-tenant collisions become cache
+ * misses (re-run, correctly attributed). `\x1f` (unit separator) can't occur in an HTTP header value, so the
+ * three fields can't be confused. undefined raw key → undefined (no dedup, unchanged).
+ */
 export function scopedIdempotencyKey(raw, source, principal) {
     return raw ? `${source ?? ""}\x1f${principal ?? ""}\x1f${raw}` : undefined;
 }

package/dist/http/principal-gate.d.ts

@@ -1,12 +1,29 @@
 import type { IncomingMessage } from "node:http";
 import type { ServiceConfig } from "../config-types.js";
+/** Coerce a possibly-repeated request header to a single string (or undefined). */
 export declare function headerStr(v: string | string[] | undefined): string | undefined;
 export declare function safeEqual(a: string, b: string): boolean;
 export declare function authorized(req: IncomingMessage, token: string): boolean;
+/** Which SYSTEM credential authenticated this request (clay 2026-06-12: source must be credential-DERIVED,
+ *  never self-declared). Returns the system name for a SERVICE_AUTH_TOKENS match; null for the legacy single
+ *  SERVICE_AUTH_TOKEN (authenticated, no system identity); undefined = no valid service credential. */
 export declare function systemFor(req: IncomingMessage, config: ServiceConfig): string | null | undefined;
+/** "presented credentials must verify":Authorization 带 Bearer/token scheme 且三路全验不过 → true。
+ *  其他 scheme(Basic 等,非我方凭证空间)不管——由原有门语义处置,避免误伤未知代理注头。 */
 export declare function bearerPresentedButUnverified(req: IncomingMessage, config: ServiceConfig): boolean;
 export declare function gatedPrincipal(req: IncomingMessage, config: ServiceConfig): string | undefined;
+/** The EXPLICIT operator gate (IMAGE-API-DESIGN.md §P2.4a MUST-FIX) — NOT the bare `isOperator` (whose empty-list
+ *  "true-for-all" is a world-writable RCE door the instant OPERATOR_PRINCIPALS is empty). Requires a non-empty
+ *  operator set AND a present principal IN it. The same form the preempt/resume endpoints already use. */
 export declare function explicitOperatorOk(principal: string | undefined, operatorPrincipals: readonly string[]): boolean;
+/** May `principal` act as an OPERATOR on the F4 approval queue? Empty `operatorPrincipals` = legacy
+ *  behavior (the shared service token IS the operator boundary → everyone authenticated is an operator).
+ *  Otherwise only listed principals are operators. */
 export declare function isOperator(principal: string | undefined, operatorPrincipals: readonly string[]): boolean;
+/** Operator check WITHOUT the empty-list "everyone is an operator" legacy fallback — an EMPTY `operatorPrincipals`
+ *  yields `false` (no one is an operator). Use this where empty-operators-means-all would be a SECURITY hole rather
+ *  than a back-compat convenience: image VISIBILITY scoping (a tenant-scoped image must not leak to every caller
+ *  just because OPERATOR_PRINCIPALS is unset). Adversarial-review HIGH: `isOperator([], p)=true` made
+ *  `latestPublished(..., {operator:true})` bypass tenant visibility for any caller on an operator-less deployment. */
 export declare function explicitOperator(principal: string | undefined, operatorPrincipals: readonly string[]): boolean;
 //# sourceMappingURL=principal-gate.d.ts.map

package/dist/http/principal-gate.js

@@ -1,5 +1,15 @@
+/**
+ * design/158 A9 seam — credential/identity primitives, extracted VERBATIM out of `http/server.ts`.
+ *
+ * Every per-domain route module needs `gatedPrincipal` (80 call sites in the old monolith), which pulls in
+ * `bearerPresentedButUnverified` → `systemFor` → `authorized` → `safeEqual`. They live here (a leaf that only
+ * depends on `node:*`, `../security.js` and the config TYPE) so `http/routes/*` never value-imports `server.ts`.
+ *
+ * Pure move: bodies are byte-identical to `server.ts:682/693/9310/9779/9789/9796`.
+ */
 import { timingSafeEqual } from "node:crypto";
 import { verifiedPrincipal, ssoVerifiedPrincipal } from "../security.js";
+/** Coerce a possibly-repeated request header to a single string (or undefined). */
 export function headerStr(v) {
     return Array.isArray(v) ? v[0] : v;
 }
@@ -10,8 +20,13 @@ export function safeEqual(a, b) {
 }
 export function authorized(req, token) {
     const h = req.headers.authorization ?? "";
+    // Constant-time compare so the service token can't be recovered byte-by-byte via response-timing (a plain
+    // `===` short-circuits on the first mismatching char). Length is allowed to leak (standard for this pattern).
     return safeEqual(h, `Bearer ${token}`) || safeEqual(h, `token ${token}`);
 }
+/** Which SYSTEM credential authenticated this request (clay 2026-06-12: source must be credential-DERIVED,
+ *  never self-declared). Returns the system name for a SERVICE_AUTH_TOKENS match; null for the legacy single
+ *  SERVICE_AUTH_TOKEN (authenticated, no system identity); undefined = no valid service credential. */
 export function systemFor(req, config) {
     for (const [tok, system] of Object.entries(config.authTokens ?? {})) {
         if (authorized(req, tok))
@@ -21,31 +36,48 @@ export function systemFor(req, config) {
         return null;
     return undefined;
 }
+/** "presented credentials must verify":Authorization 带 Bearer/token scheme 且三路全验不过 → true。
+ *  其他 scheme(Basic 等,非我方凭证空间)不管——由原有门语义处置,避免误伤未知代理注头。 */
 export function bearerPresentedButUnverified(req, config) {
     const h = req.headers.authorization;
     if (typeof h !== "string" || !/^(Bearer|token) /i.test(h))
         return false;
     if (ssoVerifiedPrincipal(req))
-        return false;
+        return false; // registry JWT 已在入口预认证验过(签名真源)
     if (systemFor(req, config) !== undefined)
-        return false;
+        return false; // service token(单一或 per-system)
     if (config.traceToken && authorized(req, config.traceToken))
-        return false;
+        return false; // 只读 trace 凭证
     return true;
 }
 export function gatedPrincipal(req, config) {
+    // 实测抓获的软鉴权:出示了 Bearer/token 凭证但验不过任何已知凭证(service token 单/多、
+    // traceToken、registry SSO-JWT)⇒ 无可信身份,绝不回退 spoofable principal 头——此前伪造凭证被静默忽略、
+    // 拿 principal 头的 owner 视图(200 空列表),会把轮换错配掩蔽成假健康。未出示凭证(纯 BFF 头姿势)不受
+    // 影响;POST 面在全局门后调用=凭证已验,语义不变。
     if (bearerPresentedButUnverified(req, config))
         return undefined;
     return verifiedPrincipal(req, config);
 }
+/** The EXPLICIT operator gate (IMAGE-API-DESIGN.md §P2.4a MUST-FIX) — NOT the bare `isOperator` (whose empty-list
+ *  "true-for-all" is a world-writable RCE door the instant OPERATOR_PRINCIPALS is empty). Requires a non-empty
+ *  operator set AND a present principal IN it. The same form the preempt/resume endpoints already use. */
 export function explicitOperatorOk(principal, operatorPrincipals) {
     return operatorPrincipals.length > 0 && principal !== undefined && operatorPrincipals.includes(principal);
 }
+/** May `principal` act as an OPERATOR on the F4 approval queue? Empty `operatorPrincipals` = legacy
+ *  behavior (the shared service token IS the operator boundary → everyone authenticated is an operator).
+ *  Otherwise only listed principals are operators. */
 export function isOperator(principal, operatorPrincipals) {
     if (operatorPrincipals.length === 0)
         return true;
     return principal !== undefined && operatorPrincipals.includes(principal);
 }
+/** Operator check WITHOUT the empty-list "everyone is an operator" legacy fallback — an EMPTY `operatorPrincipals`
+ *  yields `false` (no one is an operator). Use this where empty-operators-means-all would be a SECURITY hole rather
+ *  than a back-compat convenience: image VISIBILITY scoping (a tenant-scoped image must not leak to every caller
+ *  just because OPERATOR_PRINCIPALS is unset). Adversarial-review HIGH: `isOperator([], p)=true` made
+ *  `latestPublished(..., {operator:true})` bypass tenant visibility for any caller on an operator-less deployment. */
 export function explicitOperator(principal, operatorPrincipals) {
     return operatorPrincipals.length > 0 && principal !== undefined && operatorPrincipals.includes(principal);
 }

package/dist/http/route-ctx.d.ts

@@ -1,3 +1,19 @@
+/**
+ * design/158 A9 — 路由域装配缝(`handle()` 按路由域拆多文件 + 装配器)。
+ *
+ * `createHttpServer` 建**一次** `RouteCtxBase`(deps/registry/helpers/local 四格),`handle()` 每请求把它
+ * 加上一格 `req`(每请求局部量)交给按序尝试的域表。域模块只从这里取自己那份窄切片,**在函数首行解构**
+ * (`const { deps } = ctx;` / `const { readJson } = ctx.helpers;`)——于是搬过去的路由体逐字不变。
+ *
+ * 「已处理」语义:域入口 `handle<Domain>(req, res, url, ctx): Promise<boolean>`,true=本域已应答(调用方
+ * 立即 return),false=没匹配上、继续下一个域。实现姿势见 routes/*.ts:路由体原样放进一个返回 void 的
+ * 内层函数,函数尾把 `miss.fell = true`——原来的每一个裸 `return;` 于是天然等价于「已处理」,一处都不用改写
+ * (嵌套闭包里的 `return;` 语义也原样保住)。
+ *
+ * 分层:routes/* 只许值 import http/ 的叶子(send.ts / principal-gate.ts / route-ctx.ts / tar.ts …)与 src 下
+ * 的普通模块,**绝不可值 import server.ts**——那条边会闭合运行时装载环(test/module-cycle-gate.test.ts)。
+ * 本文件对 server.ts 的引用一律 `import type`(tsc 擦除,非装载边)。
+ */
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { TaskStream, TaskSpec, TaskResult, QuestionAnswer, CheckpointToken, ResumeOutcome } from "@sema-agent/core";
 import type { FlatServiceDeps, RequestAuth } from "./server.js";
@@ -6,6 +22,7 @@ import type { IdempotencyCache } from "./idempotency.js";
 import type { ImagesLocal } from "./routes/images.js";
 import type { SessionsLocal } from "./routes/sessions.js";
 import type { SessionSyncLocal } from "./routes/session-sync.js";
+/** 跨域可变状态 = lens1 §C2 实测的那 8 条「运行期登记簿」,一个对象。 */
 export interface RunRegistry {
     idemCache: IdempotencyCache<{
         status: number;
@@ -16,11 +33,13 @@ export interface RunRegistry {
     cancelledViaVerb: Set<string>;
     steerableRuns: Map<string, TaskStream>;
     wakeParkMints: Map<string, Promise<void>>;
+    /** 裸 number 的登记簿(`let` 拆不出闭包)—— 装进盒子才能跨模块自增/自减。 */
     counters: {
         uncountedBillableInflight: number;
         admittedInflight: number;
     };
 }
+/** 跨 ≥5 域的无状态助手(依赖只有 deps/config),外加同族的体读取器与 owner 门。 */
 export interface RouteHelpers {
     readJson(req: IncomingMessage): Promise<unknown>;
     readRawBody(req: IncomingMessage, max: number): Promise<Buffer>;
@@ -42,17 +61,27 @@ export interface RouteHelpers {
         sessionId: string | null;
     }, face: string, notFoundError?: string): boolean;
 }
+/** 单域独占状态(lens1 实测 12 条)——不进 registry,跟着各自的域模块走;每个 server 实例一份
+ *  (模块级会把 rate-limiter / 缓存跨实例串味,测试里一个进程建几十个 server)。 */
 export interface RouteLocals {
     images: ImagesLocal;
     sessions: SessionsLocal;
     sessionSync: SessionSyncLocal;
 }
+/** 每请求局部量里**跨域**的那几个(lens1 §C2:record 的日志闩 + tasks/stream 写、prelude 读的两个)。 */
 export interface RouteRequestState {
     streamTaskId: string | undefined;
     streamDetached: boolean;
+    /** 凭证派生的调用方系统身份(`source`)。handle() 的鉴权门是**唯一**赋值点,域模块只读。 */
     source: string | null;
 }
+/** 提交/续跑「腿」= 跨域共享的**有状态**长流程(不像 {@link RouteHelpers} 那样只依赖 deps/config:它们要写
+ *  run log、发 fleet 帧、走 markResuming CAS、驱动模型)。A9 上批的停点就在这里——tasks/runs 两域共用
+ *  `prepareSpec`,approvals/assistant/notify-wake 三域共用 resume 家族,把它们跟着任一域搬都会造出
+ *  routes/* 互相值 import 的第二条环。做法:留在 `createHttpServer` 闭包里(实现逐字不动),只把**函数引用**
+ *  装进这一格,域模块经 `ctx.legs.*` 调用。类型化 ⇒ 腿的形漂了是编译红,不是运行时静默 404。 */
 export interface RouteLegs {
+    /** POST /v1/tasks · /v1/tasks/stream · /v1/runs 的共同前段:读体 → 校验 → resolveSpec。null = 已应答(400/…)。 */
     prepareSpec(req: IncomingMessage, res: ServerResponse): Promise<{
         spec: TaskSpec;
         auth?: RequestAuth;
@@ -64,11 +93,14 @@ export interface RouteLegs {
         jobId?: string;
         body: TaskRequestBody;
     } | null>;
+    /** 同步腿的终局记账(计费/配额/指标),tasks 域用。 */
     finalizeTaskResult(result: TaskResult, principal: string | undefined, objective: string, sessionId: string | undefined): void;
+    /** approvals 决策腿:session → pending checkpoint → markResuming CAS → 驱动续跑。 */
     resumeCheckpoint(sessionId: string, decision: "approve" | "deny", reason: string | undefined, req?: IncomingMessage, answer?: QuestionAnswer, binding?: DecideBinding, onResumeCommitted?: (overrideSessionId?: string) => Promise<void>): Promise<{
         status: number;
         body: object;
     }>;
+    /** 全 resume 家族的共同下半场(lease admission + 写 run log + fleet 发布)。 */
     driveResumeIntoRunLog(args: {
         token: CheckpointToken;
         sessionId: string;
@@ -86,14 +118,17 @@ export interface RouteLegs {
         status: number;
         body: object;
     }>;
+    /** assistant 抢占腿的复位(gate-kind 守卫 + 驱动)。 */
     resumePreempted(sessionId: string, req: IncomingMessage | undefined): Promise<{
         status: number;
         body: object;
     }>;
+    /** notify-wake 域:唤醒一条 parked checkpoint。 */
     resumeWake(sessionId: string, message: string | undefined, caller: string | undefined, req: IncomingMessage | undefined): Promise<{
         status: number;
         body: object;
     }>;
+    /** assistant plan_review 三态腿。 */
     resumePlanReview(sessionId: string, decision: "approve" | "edit" | "reject", editedPlan: string | undefined, reason: string | undefined, req: IncomingMessage | undefined): Promise<{
         status: number;
         body: object;
@@ -110,6 +145,7 @@ export interface RouteCtx extends RouteCtxBase {
     req: RouteRequestState;
 }
 export type RouteHandler = (req: IncomingMessage, res: ServerResponse, url: string, ctx: RouteCtx) => Promise<boolean>;
+/** 域实现的收尾闩:见文件头「已处理」语义。 */
 export interface RouteMiss {
     fell: boolean;
 }

package/dist/http/routes/approvals-assistant.d.ts

@@ -1,3 +1,15 @@
+/**
+ * design/158 A9 域模块 —— 人在环审批面(durable F4 + legacy)与 assistant-scheduler 三动词。
+ *
+ * 路由(前缀 `/v1/approvals` 与 `/v1/assistant`):
+ *   · durable 腿(接了 checkpointStore 时优先):list / stream(SSE 原生推送)/ decide|answer / preempt /
+ *     resume / plan_review;
+ *   · legacy 腿(仅 approvalStore):list / by-id / decide —— 直连门部署下**必须**打不到(fail closed)。
+ *
+ * 所有会**烧模型**的续跑都经 `ctx.legs.*`(resumeCheckpoint / resumePreempted / resumePlanReview)走 resume
+ * 家族的同一条腿:lease admission、markResuming CAS、写 run log、发 fleet 帧都在腿里,本域只做入站鉴权/形状门。
+ * 本域零可变状态(抢占登记簿 `preemptableRuns` 属跨域 registry)。
+ */
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { QuestionAnswer } from "@sema-agent/core";
 import type { CheckpointStoreFull } from "../../plugins/store-backend.js";
@@ -5,7 +17,20 @@ import type { RouteCtx } from "../route-ctx.js";
 export declare const ASSISTANT_PREEMPT_RE: RegExp;
 export declare const ASSISTANT_RESUME_RE: RegExp;
 export declare const ASSISTANT_PLAN_REVIEW_RE: RegExp;
+/** Structural check for an operator-supplied QuestionAnswer (durable ask resume, TC-5.4). Strict on the
+ *  load-bearing shape — `answers[]` non-empty, each `{header: string, selected: string[], note?: string}` —
+ *  so a typo'd payload fails the request instead of resuming the task with an answer the tool can't use. */
 export declare function isQuestionAnswer(v: unknown): v is QuestionAnswer;
 export declare function handleApprovalsAssistant(req: IncomingMessage, res: ServerResponse, url: string, ctx: RouteCtx): Promise<boolean>;
+/**
+ * GET /v1/approvals/stream (design/80 native push): SSE — pushes pending-approval deltas so the portal
+ * SUBSCRIBES ONCE instead of polling GET /v1/approvals every ~10s (better UX: near-real-time + no client poll
+ * loop). Polls listPending(scope) and diffs against the prior snapshot: `pending` for a new suspend, `resolved`
+ * for a decided/expired/gone one. Cross-replica BY CONSTRUCTION — the poll reads the SHARED checkpoint table,
+ * so a suspend on ANY replica is seen by an operator streaming on a DIFFERENT replica. A transient DB blip
+ * heartbeats + retries (never kills the stream); a 15-min cap + req-close end it (parity with streamTaskTrace).
+ * Poll-granularity caveat: a pending that resolves AND re-suspends on the same (session,toolCallId) within one
+ * interval shows no delta — acceptable (the live snapshot is always eventually correct; no decision is missed).
+ */
 export declare function streamApprovals(req: IncomingMessage, res: ServerResponse, cs: Pick<CheckpointStoreFull, "listPending">, scope: string | undefined, pollMs?: number): Promise<void>;
 //# sourceMappingURL=approvals-assistant.d.ts.map