@sema-agent/server 7.79.3 → 7.80.1

package/dist/http/routes/memory-origin.js

@@ -3,9 +3,9 @@ import { ControlPlaneCorruptError } from "@sema-agent/core";
 import { sendJson, sendError } from "../send.js";
 import { buildOriginFence, readOriginAware } from "../../memory-origin-fence.js";
 import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal } from "../principal-gate.js";
+import { assertNever } from "../route-ctx.js";
 export const MEMORY_ORIGIN_EXTERNAL_PATH = "/v1/memory/origin/external";
 export const MEMORY_ORIGIN_CLEARANCES_PATH = "/v1/memory/origin/clearances";
-export const MEMORY_ORIGIN_CLEAR_RE = /^\/v1\/memory\/origin\/entries\/([^/]+)\/clear$/;
 const ClearRequestSchema = z.object({
     requestId: z.string().min(1),
     reason: z.string(),
@@ -106,21 +106,8 @@ function parseScopes(raw) {
     }
     return out.length > 0 ? out : null;
 }
-export async function handleMemoryOrigin(req, res, url, ctx) {
-    const miss = { fell: false };
-    await handleMemoryOriginBody(req, res, url, ctx, miss);
-    return !miss.fell;
-}
-async function handleMemoryOriginBody(req, res, url, ctx, miss) {
+export async function handleMemoryOrigin(req, res, match, ctx) {
     const { deps } = ctx;
-    const path = url.split("?")[0] ?? url;
-    const isExternal = req.method === "GET" && path === MEMORY_ORIGIN_EXTERNAL_PATH;
-    const isClearances = req.method === "GET" && path === MEMORY_ORIGIN_CLEARANCES_PATH;
-    const clearMatch = req.method === "POST" ? MEMORY_ORIGIN_CLEAR_RE.exec(path) : null;
-    if (!isExternal && !isClearances && clearMatch === null) {
-        miss.fell = true;
-        return;
-    }
     const principal = gatedPrincipal(req, deps.config);
     if (deps.config.requirePrincipal && !principal) {
         sendPrincipalRefusal(res, req, deps.config);
@@ -135,61 +122,74 @@ async function handleMemoryOriginBody(req, res, url, ctx, miss) {
         sendError(res, 501, "capability.memory_engine_required", "memory origin marking and clearance are not available on this deployment — they require a wired memory engine (MEMORY_ENGINE=on) whose backend owns the engine control plane (controlPlaneRoot); the clearance ledger and its write-ahead custody rows live in that plane, and on a backend without it they would land on one replica's local disk");
         return;
     }
-    if (isExternal) {
-        const scopes = parseScopes(new URL(req.url ?? "", "http://x").searchParams.getAll("scopes"));
-        if (scopes === null) {
-            sendError(res, 400, "request.query_invalid", "`scopes` is required and must name at least one memory scope (comma-separated, e.g. `?scopes=user:alice,org:acme`) — this deployment has no scope-enumeration read face yet, so name the same scope keys you use on `GET /v1/memory/export?scope=`; an answer here covers ONLY the scopes you named and an empty result must never be read as \"the store is clean\"");
+    switch (match.decl.id) {
+        case "memory-origin-external": {
+            const scopes = parseScopes(new URLSearchParams(match.search).getAll("scopes"));
+            if (scopes === null) {
+                sendError(res, 400, "request.query_invalid", "`scopes` is required and must name at least one memory scope (comma-separated, e.g. `?scopes=user:alice,org:acme`) — this deployment has no scope-enumeration read face yet, so name the same scope keys you use on `GET /v1/memory/export?scope=`; an answer here covers ONLY the scopes you named and an empty result must never be read as \"the store is clean\"");
+                return;
+            }
+            try {
+                const fence = buildOriginFence(await faces.listExternal(scopes), readOriginAware(new URLSearchParams(match.search)));
+                sendJson(res, 200, { scopes, entries: fence.entries, ...(fence.withheldOriginTagged !== undefined ? { withheldOriginTagged: fence.withheldOriginTagged } : {}) });
+            }
+            catch (err) {
+                if (!sentClassifiedFailure(res, ctx, "external", err))
+                    sendError(res, 500, "internal.error", "memory external-origin listing failed");
+            }
             return;
         }
-        try {
-            const fence = buildOriginFence(await faces.listExternal(scopes), readOriginAware(new URL(req.url ?? "", "http://x").searchParams));
-            sendJson(res, 200, { scopes, entries: fence.entries, ...(fence.withheldOriginTagged !== undefined ? { withheldOriginTagged: fence.withheldOriginTagged } : {}) });
-        }
-        catch (err) {
-            if (!sentClassifiedFailure(res, ctx, "external", err))
-                sendError(res, 500, "internal.error", "memory external-origin listing failed");
-        }
-        return;
-    }
-    if (isClearances) {
-        try {
-            sendJson(res, 200, { clearances: faces.listClearances().map(buildClearanceRowWire) });
-        }
-        catch (err) {
-            if (!sentClassifiedFailure(res, ctx, "clearances", err))
-                sendError(res, 500, "internal.error", "memory origin clearance listing failed");
+        case "memory-origin-clearances": {
+            try {
+                sendJson(res, 200, { clearances: faces.listClearances().map(buildClearanceRowWire) });
+            }
+            catch (err) {
+                if (!sentClassifiedFailure(res, ctx, "clearances", err))
+                    sendError(res, 500, "internal.error", "memory origin clearance listing failed");
+            }
+            return;
         }
-        return;
-    }
-    const entryId = ctx.helpers.safeDecode(clearMatch[1]);
-    if (entryId === null) {
-        sendError(res, 400, "request.id_invalid", "invalid memory entry id");
-        return;
-    }
-    const raw = await ctx.helpers.readJson(req);
-    const parsed = ClearRequestSchema.safeParse(raw);
-    if (!parsed.success) {
-        if (parsed.error.issues.some((i) => i.path.length > 0 && i.path[0] === "requestId")) {
-            sendError(res, 400, "request.request_id_required", "memory origin clearance requires a non-empty `requestId` string — it is the audit attribution of WHO cleared this marker and the server never mints one for you");
+        case "memory-origin-entry-clear": {
+            const entryId = ctx.helpers.safeDecode(match.params.entryId);
+            if (entryId === null) {
+                sendError(res, 400, "request.id_invalid", "invalid memory entry id");
+                return;
+            }
+            const raw = await ctx.helpers.readJson(req);
+            const parsed = ClearRequestSchema.safeParse(raw);
+            if (!parsed.success) {
+                if (parsed.error.issues.some((i) => i.path.length > 0 && i.path[0] === "requestId")) {
+                    sendError(res, 400, "request.request_id_required", "memory origin clearance requires a non-empty `requestId` string — it is the audit attribution of WHO cleared this marker and the server never mints one for you");
+                    return;
+                }
+                sendError(res, 400, "request.body_shape", "invalid memory origin clearance request — expected an object with a non-empty `requestId` and a `reason` string (whether an EMPTY reason is acceptable is the engine's judgment, not this layer's)");
+                return;
+            }
+            try {
+                const receipt = await faces.clear(entryId, { requestId: parsed.data.requestId, reason: parsed.data.reason });
+                ctx.deps.logger?.info?.("memory_origin_cleared", {
+                    principal: principal ?? null,
+                    entryId,
+                    clearanceId: receipt.clearanceId,
+                    claimedRequestId: parsed.data.requestId,
+                    landedSlug: receipt.landedSlug,
+                });
+                sendJson(res, 200, receipt);
+            }
+            catch (err) {
+                if (!sentClassifiedFailure(res, ctx, "clear", err))
+                    sendError(res, 500, "internal.error", "memory origin clearance failed");
+            }
             return;
         }
-        sendError(res, 400, "request.body_shape", "invalid memory origin clearance request — expected an object with a non-empty `requestId` and a `reason` string (whether an EMPTY reason is acceptable is the engine's judgment, not this layer's)");
-        return;
-    }
-    try {
-        const receipt = await faces.clear(entryId, { requestId: parsed.data.requestId, reason: parsed.data.reason });
-        ctx.deps.logger?.info?.("memory_origin_cleared", {
-            principal: principal ?? null,
-            entryId,
-            clearanceId: receipt.clearanceId,
-            claimedRequestId: parsed.data.requestId,
-            landedSlug: receipt.landedSlug,
-        });
-        sendJson(res, 200, receipt);
-    }
-    catch (err) {
-        if (!sentClassifiedFailure(res, ctx, "clear", err))
-            sendError(res, 500, "internal.error", "memory origin clearance failed");
+        default:
+            return assertNever(match.decl.id);
     }
 }
+export const MEMORY_ORIGIN_ROUTES = [
+    { id: "memory-origin-external", path: MEMORY_ORIGIN_EXTERNAL_PATH, credentialGated: ["GET"], methods: ["GET"] },
+    { id: "memory-origin-clearances", path: MEMORY_ORIGIN_CLEARANCES_PATH, credentialGated: ["GET"], methods: ["GET"] },
+    { id: "memory-origin-entry-clear", pattern: /^\/v1\/memory\/origin\/entries\/(?<entryId>[^/]+)\/clear$/, label: "/v1/memory/origin/entries/:entryId/clear", methods: ["POST"] },
+    { prefix: "/v1/memory/origin/entries/", credentialGated: ["POST"] },
+];
 //# sourceMappingURL=memory-origin.js.map

package/dist/http/routes/memory-policy.d.ts

@@ -6,7 +6,7 @@
  * 越界一律 404(零存在性 oracle)。本域零可变状态。
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
-import type { RouteCtx } from "../route-ctx.js";
+import type { RouteCtx, RouteMatch, RouteIdsOf } from "../route-ctx.js";
 /**
  * [ref] 件3([ref] A2 车立的欠账,[ref] 我方认领)—— `GET /v1/memory/export` 的 keyset 分页上限。
  *
@@ -20,5 +20,24 @@ import type { RouteCtx } from "../route-ctx.js";
  * 本形解决,库侧的读放大另案。
  */
 export declare const MEMORY_EXPORT_MAX_LIMIT = 500;
-export declare function handleMemoryPolicy(req: IncomingMessage, res: ServerResponse, url: string, ctx: RouteCtx): Promise<boolean>;
+/** 路由体 = 从 `server.ts` 的 `handle()` 里**整段剪切**过来的原文(唯一改动:统一去缩进两格)。裸 `return;`
+ *  的语义原样 =「本域已应答」;走到函数尾才是「没匹配上」,置 `miss.fell` 交回装配器继续下一个域。
+ *  跨域的东西(deps / 助手 / 单域状态)一律在首行解构出来,于是下面每一行都逐字不变。 */
+export declare function handleMemoryPolicy(req: IncomingMessage, res: ServerResponse, match: RouteMatch<MemoryPolicyRouteId>, ctx: RouteCtx): Promise<void>;
+export declare const MEMORY_POLICY_ROUTES: readonly [{
+    readonly id: "memory-export";
+    readonly path: "/v1/memory/export";
+    readonly methods: readonly ["GET"];
+}, {
+    readonly id: "policy";
+    readonly path: "/v1/policy";
+    readonly methods: readonly ["GET"];
+}, {
+    readonly id: "memory-sync-scope";
+    readonly pattern: RegExp;
+    readonly label: "/v1/memory/sync/:scope";
+    readonly methods: readonly ["POST"];
+}];
+/** 本域可分派行的 `id` 闭集 —— handler 的 `switch` 按它判穷尽(漏一口 = 编译红)。 */
+export type MemoryPolicyRouteId = RouteIdsOf<typeof MEMORY_POLICY_ROUTES>;
 //# sourceMappingURL=memory-policy.d.ts.map

package/dist/http/routes/memory-policy.js

@@ -3,6 +3,7 @@ import { parseMemorySyncRequest } from "../../memory-sync.js";
 import { sendJson, sendError } from "../send.js";
 import { buildOriginFence, readOriginAware } from "../../memory-origin-fence.js";
 import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal } from "../principal-gate.js";
+import { assertNever } from "../route-ctx.js";
 const ORG_PREFIX = "org:";
 export const MEMORY_EXPORT_MAX_LIMIT = 500;
 function encodeExportCursor(c) {
@@ -60,133 +61,136 @@ function sendScopeGateRefusal(res, gate) {
     sendError(res, 404, "not_found.memory_scope", "not found");
     return true;
 }
-export async function handleMemoryPolicy(req, res, url, ctx) {
-    const miss = { fell: false };
-    await handleMemoryPolicyBody(req, res, url, ctx, miss);
-    return !miss.fell;
-}
-async function handleMemoryPolicyBody(req, res, url, ctx, miss) {
+export async function handleMemoryPolicy(req, res, match, ctx) {
     const { deps } = ctx;
     const { readJson } = ctx.helpers;
-    if (url === "/v1/memory/export" && req.method === "GET") {
-        const principal = gatedPrincipal(req, deps.config);
-        if (!principal) {
-            sendError(res, 401, "auth.unauthorized", "unauthorized");
-            return;
-        }
-        if (deps.config.memoryEngineBackend === "file" || !deps.memoryExport) {
-            sendError(res, 501, "capability.memory_store_required", "memory export requires a DB memory backend (MEMORY_ENGINE_BACKEND=pg|tidb)");
-            return;
-        }
-        const q = new URL(req.url ?? "", "http://x").searchParams;
-        const scope = q.get("scope");
-        if (!scope) {
-            sendError(res, 400, "request.query_invalid", "missing ?scope=<key>");
-            return;
-        }
-        if (sendScopeGateRefusal(res, await gateMemoryScope(deps, principal, scope, "read")))
-            return;
-        const limitRaw = q.get("limit");
-        if (limitRaw !== null && !(/^[0-9]+$/.test(limitRaw) && Number(limitRaw) >= 1 && Number(limitRaw) <= MEMORY_EXPORT_MAX_LIMIT)) {
-            sendError(res, 400, "request.query_invalid", `limit must be a decimal integer in 1..${MEMORY_EXPORT_MAX_LIMIT}`);
-            return;
-        }
-        const beforeRaw = q.get("before");
-        if (beforeRaw !== null && limitRaw === null) {
-            sendError(res, 400, "request.query_invalid", "before requires an explicit limit — without one this endpoint returns the whole scope by contract");
+    switch (match.decl.id) {
+        case "memory-export": {
+            const principal = gatedPrincipal(req, deps.config);
+            if (!principal) {
+                sendError(res, 401, "auth.unauthorized", "unauthorized");
+                return;
+            }
+            if (deps.config.memoryEngineBackend === "file" || !deps.memoryExport) {
+                sendError(res, 501, "capability.memory_store_required", "memory export requires a DB memory backend (MEMORY_ENGINE_BACKEND=pg|tidb)");
+                return;
+            }
+            const q = new URLSearchParams(match.search);
+            const scope = q.get("scope");
+            if (!scope) {
+                sendError(res, 400, "request.query_invalid", "missing ?scope=<key>");
+                return;
+            }
+            if (sendScopeGateRefusal(res, await gateMemoryScope(deps, principal, scope, "read")))
+                return;
+            const limitRaw = q.get("limit");
+            if (limitRaw !== null && !(/^[0-9]+$/.test(limitRaw) && Number(limitRaw) >= 1 && Number(limitRaw) <= MEMORY_EXPORT_MAX_LIMIT)) {
+                sendError(res, 400, "request.query_invalid", `limit must be a decimal integer in 1..${MEMORY_EXPORT_MAX_LIMIT}`);
+                return;
+            }
+            const beforeRaw = q.get("before");
+            if (beforeRaw !== null && limitRaw === null) {
+                sendError(res, 400, "request.query_invalid", "before requires an explicit limit — without one this endpoint returns the whole scope by contract");
+                return;
+            }
+            const decoded = beforeRaw === null ? undefined : decodeExportCursor(beforeRaw);
+            if (decoded !== undefined && !decoded.ok) {
+                sendError(res, 400, "request.query_invalid", "before must be the opaque `nextBefore` cursor from a previous page of this endpoint", { detail: decoded.why });
+                return;
+            }
+            try {
+                const fence = buildOriginFence(await deps.memoryExport(scope), readOriginAware(new URLSearchParams(match.search)));
+                const entries = fence.entries;
+                const withheld = fence.withheldOriginTagged !== undefined ? { withheldOriginTagged: fence.withheldOriginTagged } : {};
+                if (limitRaw === null) {
+                    sendJson(res, 200, { scope, exportedAt: new Date().toISOString(), entries, ...withheld });
+                    return;
+                }
+                const sorted = [...entries].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+                const after = decoded?.ok === true ? sorted.filter((e) => e.id > decoded.cursor.id) : sorted;
+                const page = after.slice(0, Number(limitRaw));
+                const last = page[page.length - 1];
+                const hasMore = last !== undefined && after.length > page.length;
+                sendJson(res, 200, {
+                    scope,
+                    exportedAt: new Date().toISOString(),
+                    entries: page,
+                    ...(hasMore ? { truncated: true, nextBefore: encodeExportCursor({ id: last.id }) } : {}),
+                    ...withheld,
+                });
+            }
+            catch (err) {
+                deps.logger?.warn?.("memory_export_failed", { scope, err: String(err) });
+                sendError(res, 500, "internal.error", "memory export failed");
+            }
             return;
         }
-        const decoded = beforeRaw === null ? undefined : decodeExportCursor(beforeRaw);
-        if (decoded !== undefined && !decoded.ok) {
-            sendError(res, 400, "request.query_invalid", "before must be the opaque `nextBefore` cursor from a previous page of this endpoint", { detail: decoded.why });
+        case "memory-sync-scope": {
+            const principal = gatedPrincipal(req, deps.config);
+            if (!principal) {
+                sendError(res, 401, "auth.unauthorized", "unauthorized");
+                return;
+            }
+            if (deps.config.memoryEngineBackend === "file" || !deps.memorySync) {
+                sendError(res, 501, "capability.memory_store_required", "memory sync requires a DB memory backend (MEMORY_ENGINE_BACKEND=pg|tidb)");
+                return;
+            }
+            let scope;
+            try {
+                scope = decodeURIComponent(match.params.scope);
+            }
+            catch {
+                sendError(res, 400, "memory_sync_invalid_scope", "malformed percent-encoding in :scope");
+                return;
+            }
+            if (scope.length === 0) {
+                sendError(res, 400, "memory_sync_invalid_scope", "missing :scope");
+                return;
+            }
+            if (sendScopeGateRefusal(res, await gateMemoryScope(deps, principal, scope, "write")))
+                return;
+            const body = await readJson(req);
+            const parsed = parseMemorySyncRequest(body, scope);
+            if (!parsed.ok) {
+                sendError(res, 422, "memory_sync_invalid_body", parsed.error);
+                return;
+            }
+            try {
+                const out = await deps.memorySync(scope, parsed.value);
+                sendJson(res, 200, out);
+            }
+            catch (err) {
+                deps.logger?.warn?.("memory_sync_failed", { scope, peer: parsed.value.peer, err: String(err) });
+                sendError(res, 500, "internal.error", "memory sync failed");
+            }
             return;
         }
-        try {
-            const fence = buildOriginFence(await deps.memoryExport(scope), readOriginAware(new URL(req.url ?? "", "http://x").searchParams));
-            const entries = fence.entries;
-            const withheld = fence.withheldOriginTagged !== undefined ? { withheldOriginTagged: fence.withheldOriginTagged } : {};
-            if (limitRaw === null) {
-                sendJson(res, 200, { scope, exportedAt: new Date().toISOString(), entries, ...withheld });
+        case "policy": {
+            const principal = gatedPrincipal(req, deps.config);
+            if (deps.config.requirePrincipal && !principal) {
+                sendPrincipalRefusal(res, req, deps.config);
                 return;
             }
-            const sorted = [...entries].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-            const after = decoded?.ok === true ? sorted.filter((e) => e.id > decoded.cursor.id) : sorted;
-            const page = after.slice(0, Number(limitRaw));
-            const last = page[page.length - 1];
-            const hasMore = last !== undefined && after.length > page.length;
             sendJson(res, 200, {
-                scope,
-                exportedAt: new Date().toISOString(),
-                entries: page,
-                ...(hasMore ? { truncated: true, nextBefore: encodeExportCursor({ id: last.id }) } : {}),
-                ...withheld,
+                autonomy: deps.config.autonomy ?? null,
+                commandPolicy: deps.config.commandPolicy ?? [],
+                approvalRequire: deps.config.approvalRequire,
+                limits: {
+                    maxTaskCostUsd: deps.config.maxTaskCostUsd,
+                    maxTaskTokens: deps.config.maxTaskTokens,
+                    maxPrincipalCostUsd: deps.config.maxPrincipalCostUsd,
+                    costQuotaWindowSec: deps.config.costQuotaWindowSec,
+                },
             });
-        }
-        catch (err) {
-            deps.logger?.warn?.("memory_export_failed", { scope, err: String(err) });
-            sendError(res, 500, "internal.error", "memory export failed");
-        }
-        return;
-    }
-    if (req.method === "POST" && url.startsWith("/v1/memory/sync/")) {
-        const principal = gatedPrincipal(req, deps.config);
-        if (!principal) {
-            sendError(res, 401, "auth.unauthorized", "unauthorized");
-            return;
-        }
-        if (deps.config.memoryEngineBackend === "file" || !deps.memorySync) {
-            sendError(res, 501, "capability.memory_store_required", "memory sync requires a DB memory backend (MEMORY_ENGINE_BACKEND=pg|tidb)");
-            return;
-        }
-        let scope;
-        try {
-            scope = decodeURIComponent(url.slice("/v1/memory/sync/".length));
-        }
-        catch {
-            sendError(res, 400, "memory_sync_invalid_scope", "malformed percent-encoding in :scope");
-            return;
-        }
-        if (scope.length === 0) {
-            sendError(res, 400, "memory_sync_invalid_scope", "missing :scope");
-            return;
-        }
-        if (sendScopeGateRefusal(res, await gateMemoryScope(deps, principal, scope, "write")))
-            return;
-        const body = await readJson(req);
-        const parsed = parseMemorySyncRequest(body, scope);
-        if (!parsed.ok) {
-            sendError(res, 422, "memory_sync_invalid_body", parsed.error);
-            return;
-        }
-        try {
-            const out = await deps.memorySync(scope, parsed.value);
-            sendJson(res, 200, out);
-        }
-        catch (err) {
-            deps.logger?.warn?.("memory_sync_failed", { scope, peer: parsed.value.peer, err: String(err) });
-            sendError(res, 500, "internal.error", "memory sync failed");
-        }
-        return;
-    }
-    if (url === "/v1/policy" && req.method === "GET") {
-        const principal = gatedPrincipal(req, deps.config);
-        if (deps.config.requirePrincipal && !principal) {
-            sendPrincipalRefusal(res, req, deps.config);
             return;
         }
-        sendJson(res, 200, {
-            autonomy: deps.config.autonomy ?? null,
-            commandPolicy: deps.config.commandPolicy ?? [],
-            approvalRequire: deps.config.approvalRequire,
-            limits: {
-                maxTaskCostUsd: deps.config.maxTaskCostUsd,
-                maxTaskTokens: deps.config.maxTaskTokens,
-                maxPrincipalCostUsd: deps.config.maxPrincipalCostUsd,
-                costQuotaWindowSec: deps.config.costQuotaWindowSec,
-            },
-        });
-        return;
+        default:
+            return assertNever(match.decl.id);
     }
-    miss.fell = true;
 }
+export const MEMORY_POLICY_ROUTES = [
+    { id: "memory-export", path: "/v1/memory/export", methods: ["GET"] },
+    { id: "policy", path: "/v1/policy", methods: ["GET"] },
+    { id: "memory-sync-scope", pattern: /^\/v1\/memory\/sync\/(?<scope>.*)$/, label: "/v1/memory/sync/:scope", methods: ["POST"] },
+];
 //# sourceMappingURL=memory-policy.js.map

package/dist/http/routes/notify-wake.d.ts

@@ -9,17 +9,27 @@
  * 都在腿里),而不是在本域自建第二条驱动路径。本域零可变状态。
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
-import { type RouteCtx } from "../route-ctx.js";
+import { type RouteCtx, type RouteMatch, type RouteIdsOf } from "../route-ctx.js";
 /**
- * `POST /v1/sessions/:id/wake` 的路由形 —— **单源导出**,因为它有两个消费者:本模块的分发,
- * 和 `server.ts` 的 `isBillableSubmitPath`(wake 会烧模型,必须吃 drain / model-roster-pending /
- * 无 service-token 三道提交门)。
- *
- * 🔴 为什么提成常量:2026-07-31 的缝合审查出这两处**曾经不同步** —— 匹配形写死在本文件里,
- * 名单在 server.ts 里,wake 从来没进过名单,于是同一条 `driveResumeIntoRunLog` 模型腿
- * 从 `/v1/assistant/tasks/:id/resume` 进来受三道门管、从 wake 进来一道都不受。
- * 共用一个常量之后,再想漏就得两处一起改。
+ * 🔴 `POST /v1/sessions/:id/wake` 的匹配形与它的 `billable` 位**同住一行声明**(下面的
+ * `NOTIFY_WAKE_ROUTES`)。历史:2026-07-31 的缝合审查出这两件事**曾经不同步** —— 匹配形写死在本文件的
+ * 判路代码里、`isBillableSubmitPath` 的名单写在 `server.ts` 里,wake 从来没进过名单,于是同一条
+ * `driveResumeIntoRunLog` 模型腿从 `/v1/assistant/tasks/:id/resume` 进来受三道提交门管、从 wake 进来
+ * 一道都不受。S-146 让两件事变成同一行的两列,再想漏就得把一行拆成两处才做得到。
  */
-export declare const SESSION_WAKE_RE: RegExp;
-export declare function handleNotifyWake(req: IncomingMessage, res: ServerResponse, url: string, ctx: RouteCtx): Promise<boolean>;
+export declare function handleNotifyWake(req: IncomingMessage, res: ServerResponse, match: RouteMatch<NotifyWakeRouteId>, ctx: RouteCtx): Promise<void>;
+export declare const NOTIFY_WAKE_ROUTES: readonly [{
+    readonly id: "session-wake";
+    readonly pattern: RegExp;
+    readonly label: "/v1/sessions/:id/$verb";
+    readonly billable: true;
+    readonly methods: readonly ["POST"];
+}, {
+    readonly id: "session-notify";
+    readonly pattern: RegExp;
+    readonly label: "/v1/sessions/:id/$verb";
+    readonly methods: readonly ["POST"];
+}];
+/** 本域可分派行的 `id` 闭集 —— handler 的 `switch` 按它判穷尽(漏一口 = 编译红)。 */
+export type NotifyWakeRouteId = RouteIdsOf<typeof NOTIFY_WAKE_ROUTES>;
 //# sourceMappingURL=notify-wake.d.ts.map