@sema-agent/server 7.79.3 → 7.80.1

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

@@ -59,7 +59,7 @@
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { MemoryImportReport } from "@sema-agent/core";
-import type { RouteCtx } from "../route-ctx.js";
+import type { RouteCtx, RouteMatch, RouteIdsOf } from "../route-ctx.js";
 export declare const MEMORY_BUNDLE_EXPORT_PATH = "/v1/memory/export";
 export declare const MEMORY_BUNDLE_IMPORT_PATH = "/v1/memory/import";
 /**
@@ -105,5 +105,18 @@ export declare function buildImportReportWire(r: MemoryImportReport): {
     }[];
     custodyAppended: number;
 };
-export declare function handleMemoryBundle(req: IncomingMessage, res: ServerResponse, url: string, ctx: RouteCtx): Promise<boolean>;
+export declare function handleMemoryBundle(req: IncomingMessage, res: ServerResponse, match: RouteMatch<MemoryBundleRouteId>, ctx: RouteCtx): Promise<void>;
+export declare const MEMORY_BUNDLE_ROUTES: readonly [{
+    readonly id: "memory-import";
+    readonly path: "/v1/memory/import";
+    readonly credentialGated: readonly ["POST"];
+    readonly methods: readonly ["POST"];
+}, {
+    readonly id: "memory-bundle-export";
+    readonly path: "/v1/memory/export";
+    readonly credentialGated: readonly ["POST"];
+    readonly methods: readonly ["POST"];
+}];
+/** 本域可分派行的 `id` 闭集 —— handler 的 `switch` 按它判穷尽(漏一口 = 编译红)。 */
+export type MemoryBundleRouteId = RouteIdsOf<typeof MEMORY_BUNDLE_ROUTES>;
 //# sourceMappingURL=memory-bundle.d.ts.map

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

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { sendJson, sendError } from "../send.js";
 import { buildOriginFencedBundle, readOriginAware } from "../../memory-origin-fence.js";
 import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal } from "../principal-gate.js";
+import { assertNever } from "../route-ctx.js";
 export const MEMORY_BUNDLE_EXPORT_PATH = "/v1/memory/export";
 export const MEMORY_BUNDLE_IMPORT_PATH = "/v1/memory/import";
 const ExportRequestSchema = z.object({ scopes: z.array(z.string().min(1)).min(1) });
@@ -56,20 +57,8 @@ export function buildImportReportWire(r) {
         custodyAppended: r.custodyAppended,
     };
 }
-export async function handleMemoryBundle(req, res, url, ctx) {
-    const miss = { fell: false };
-    await handleMemoryBundleBody(req, res, url, ctx, miss);
-    return !miss.fell;
-}
-async function handleMemoryBundleBody(req, res, url, ctx, miss) {
+export async function handleMemoryBundle(req, res, match, ctx) {
     const { deps } = ctx;
-    const path = url.split("?")[0] ?? url;
-    const isExport = req.method === "POST" && path === MEMORY_BUNDLE_EXPORT_PATH;
-    const isImport = req.method === "POST" && path === MEMORY_BUNDLE_IMPORT_PATH;
-    if (!isExport && !isImport) {
-        miss.fell = true;
-        return;
-    }
     const principal = gatedPrincipal(req, deps.config);
     if (deps.config.requirePrincipal && !principal) {
         sendPrincipalRefusal(res, req, deps.config);
@@ -86,34 +75,45 @@ async function handleMemoryBundleBody(req, res, url, ctx, miss) {
         return;
     }
     const raw = await ctx.helpers.readJson(req);
-    if (isExport) {
-        const parsed = ExportRequestSchema.safeParse(raw);
-        if (!parsed.success) {
-            sendError(res, 400, "request.body_shape", "invalid memory export request — expected an object with a non-empty `scopes` array of non-empty strings");
+    switch (match.decl.id) {
+        case "memory-bundle-export": {
+            const parsed = ExportRequestSchema.safeParse(raw);
+            if (!parsed.success) {
+                sendError(res, 400, "request.body_shape", "invalid memory export request — expected an object with a non-empty `scopes` array of non-empty strings");
+                return;
+            }
+            try {
+                const bundle = await engineExport(parsed.data.scopes);
+                sendJson(res, 200, buildOriginFencedBundle(bundle, readOriginAware(new URLSearchParams(match.search))));
+            }
+            catch (err) {
+                if (!sentClassifiedFailure(res, ctx, "export", err))
+                    sendError(res, 500, "internal.error", "memory bundle export failed");
+            }
             return;
         }
-        try {
-            const bundle = await engineExport(parsed.data.scopes);
-            sendJson(res, 200, buildOriginFencedBundle(bundle, readOriginAware(new URL(req.url ?? "", "http://x").searchParams)));
-        }
-        catch (err) {
-            if (!sentClassifiedFailure(res, ctx, "export", err))
-                sendError(res, 500, "internal.error", "memory bundle export failed");
+        case "memory-import": {
+            const parsed = ImportRequestSchema.safeParse(raw);
+            if (!parsed.success) {
+                sendError(res, 400, "request.body_shape", "invalid memory import request — expected an object with a `bundle` object");
+                return;
+            }
+            try {
+                const report = await engineImport(parsed.data.bundle);
+                sendJson(res, 200, buildImportReportWire(report));
+            }
+            catch (err) {
+                if (!sentClassifiedFailure(res, ctx, "import", err))
+                    sendError(res, 500, "internal.error", "memory bundle import failed");
+            }
+            return;
         }
-        return;
-    }
-    const parsed = ImportRequestSchema.safeParse(raw);
-    if (!parsed.success) {
-        sendError(res, 400, "request.body_shape", "invalid memory import request — expected an object with a `bundle` object");
-        return;
-    }
-    try {
-        const report = await engineImport(parsed.data.bundle);
-        sendJson(res, 200, buildImportReportWire(report));
-    }
-    catch (err) {
-        if (!sentClassifiedFailure(res, ctx, "import", err))
-            sendError(res, 500, "internal.error", "memory bundle import failed");
+        default:
+            return assertNever(match.decl.id);
     }
 }
+export const MEMORY_BUNDLE_ROUTES = [
+    { id: "memory-import", path: MEMORY_BUNDLE_IMPORT_PATH, credentialGated: ["POST"], methods: ["POST"] },
+    { id: "memory-bundle-export", path: MEMORY_BUNDLE_EXPORT_PATH, credentialGated: ["POST"], methods: ["POST"] },
+];
 //# sourceMappingURL=memory-bundle.js.map

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

@@ -94,9 +94,21 @@
  * 分层:本模块不值 import `server.ts`(那条边闭合运行时装载环),只 `import type`。
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
-import type { RouteCtx } from "../route-ctx.js";
+import type { RouteCtx, RouteMatch, RouteIdsOf } from "../route-ctx.js";
 export declare const MEMORY_ERASE_PATH = "/v1/memory/erase";
-/** 单条出处读面。带参路径 ⇒ 路由声明表(`http/route-table.ts`)里走 `pattern` 行,不是 `path` 行。 */
-export declare const MEMORY_PROVENANCE_RE: RegExp;
-export declare function handleMemoryCompliance(req: IncomingMessage, res: ServerResponse, url: string, ctx: RouteCtx): Promise<boolean>;
+export declare function handleMemoryCompliance(req: IncomingMessage, res: ServerResponse, match: RouteMatch<MemoryComplianceRouteId>, ctx: RouteCtx): Promise<void>;
+export declare const MEMORY_COMPLIANCE_ROUTES: readonly [{
+    readonly id: "memory-erase";
+    readonly path: "/v1/memory/erase";
+    readonly credentialGated: readonly ["POST"];
+    readonly methods: readonly ["POST"];
+}, {
+    readonly id: "memory-entry-provenance";
+    readonly pattern: RegExp;
+    readonly label: "/v1/memory/entries/:entryId/provenance";
+    readonly credentialGated: readonly ["GET"];
+    readonly methods: readonly ["GET"];
+}];
+/** 本域可分派行的 `id` 闭集 —— handler 的 `switch` 按它判穷尽(漏一口 = 编译红)。 */
+export type MemoryComplianceRouteId = RouteIdsOf<typeof MEMORY_COMPLIANCE_ROUTES>;
 //# sourceMappingURL=memory-compliance.d.ts.map

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

@@ -3,8 +3,8 @@ import { ControlPlaneCorruptError } from "@sema-agent/core";
 import { erasureInputSmugglesPrototypeKey } from "../../memory-operator-faces.js";
 import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal } from "../principal-gate.js";
+import { assertNever } from "../route-ctx.js";
 export const MEMORY_ERASE_PATH = "/v1/memory/erase";
-export const MEMORY_PROVENANCE_RE = /^\/v1\/memory\/entries\/([^/]+)\/provenance$/;
 const EraseRequestSchema = z.object({
     requestId: z.string().min(1),
     select: z.record(z.string(), z.unknown()),
@@ -45,20 +45,8 @@ function sentClassifiedFailure(res, ctx, face, err) {
     ctx.deps.logger?.warn?.(`memory_compliance_${face}_failed`, { err: String(err) });
     return false;
 }
-export async function handleMemoryCompliance(req, res, url, ctx) {
-    const miss = { fell: false };
-    await handleMemoryComplianceBody(req, res, url, ctx, miss);
-    return !miss.fell;
-}
-async function handleMemoryComplianceBody(req, res, url, ctx, miss) {
+export async function handleMemoryCompliance(req, res, match, ctx) {
     const { deps } = ctx;
-    const path = url.split("?")[0] ?? url;
-    const provMatch = req.method === "GET" ? MEMORY_PROVENANCE_RE.exec(path) : null;
-    const isErase = req.method === "POST" && path === MEMORY_ERASE_PATH;
-    if (provMatch === null && !isErase) {
-        miss.fell = true;
-        return;
-    }
     const principal = gatedPrincipal(req, deps.config);
     if (deps.config.requirePrincipal && !principal) {
         sendPrincipalRefusal(res, req, deps.config);
@@ -73,41 +61,52 @@ async function handleMemoryComplianceBody(req, res, url, ctx, miss) {
         sendError(res, 501, "capability.memory_engine_required", "memory provenance and erasure are not available on this deployment — they require a wired memory engine (MEMORY_ENGINE=on) whose backend owns the engine control plane (controlPlaneRoot); the file memory backend does, the pg/tidb memory backends do not (their control plane would land on a replica's local disk)");
         return;
     }
-    if (provMatch !== null) {
-        const entryId = ctx.helpers.safeDecode(provMatch[1]);
-        if (entryId === null) {
-            sendError(res, 400, "request.id_invalid", "invalid memory entry id");
+    switch (match.decl.id) {
+        case "memory-entry-provenance": {
+            const entryId = ctx.helpers.safeDecode(match.params.entryId);
+            if (entryId === null) {
+                sendError(res, 400, "request.id_invalid", "invalid memory entry id");
+                return;
+            }
+            try {
+                sendJson(res, 200, await faces.provenanceOf(entryId));
+            }
+            catch (err) {
+                if (!sentClassifiedFailure(res, ctx, "provenance", err))
+                    sendError(res, 500, "internal.error", "memory provenance read failed");
+            }
             return;
         }
-        try {
-            sendJson(res, 200, await faces.provenanceOf(entryId));
-        }
-        catch (err) {
-            if (!sentClassifiedFailure(res, ctx, "provenance", err))
-                sendError(res, 500, "internal.error", "memory provenance read failed");
-        }
-        return;
-    }
-    const raw = await ctx.helpers.readJson(req);
-    const parsed = EraseRequestSchema.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 erasure requires a non-empty `requestId` string — it is this request's idempotency identity and the server never mints one for you (a retry must carry the SAME id)");
+        case "memory-erase": {
+            const raw = await ctx.helpers.readJson(req);
+            const parsed = EraseRequestSchema.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 erasure requires a non-empty `requestId` string — it is this request's idempotency identity and the server never mints one for you (a retry must carry the SAME id)");
+                    return;
+                }
+                sendError(res, 400, "request.body_shape", "invalid memory erasure request — expected an object with a non-empty `requestId`, a `select` object, and an optional boolean `allowUnevidenced`");
+                return;
+            }
+            if (erasureInputSmugglesPrototypeKey(raw)) {
+                sendError(res, 400, "request.body_shape", "invalid memory erasure request — a key that rewrites an object's prototype (`__proto__`) is not a selector key; send exactly one of `select.ids` / `select.scope` / `select.sessionId`");
+                return;
+            }
+            try {
+                sendJson(res, 200, await faces.erase(raw));
+            }
+            catch (err) {
+                if (!sentClassifiedFailure(res, ctx, "erase", err))
+                    sendError(res, 500, "internal.error", "memory erasure failed");
+            }
             return;
         }
-        sendError(res, 400, "request.body_shape", "invalid memory erasure request — expected an object with a non-empty `requestId`, a `select` object, and an optional boolean `allowUnevidenced`");
-        return;
-    }
-    if (erasureInputSmugglesPrototypeKey(raw)) {
-        sendError(res, 400, "request.body_shape", "invalid memory erasure request — a key that rewrites an object's prototype (`__proto__`) is not a selector key; send exactly one of `select.ids` / `select.scope` / `select.sessionId`");
-        return;
-    }
-    try {
-        sendJson(res, 200, await faces.erase(raw));
-    }
-    catch (err) {
-        if (!sentClassifiedFailure(res, ctx, "erase", err))
-            sendError(res, 500, "internal.error", "memory erasure failed");
+        default:
+            return assertNever(match.decl.id);
     }
 }
+export const MEMORY_COMPLIANCE_ROUTES = [
+    { id: "memory-erase", path: MEMORY_ERASE_PATH, credentialGated: ["POST"], methods: ["POST"] },
+    { id: "memory-entry-provenance", pattern: /^\/v1\/memory\/entries\/(?<entryId>[^/]+)\/provenance$/, label: "/v1/memory/entries/:entryId/provenance", credentialGated: ["GET"], methods: ["GET"] },
+];
 //# sourceMappingURL=memory-compliance.js.map

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

@@ -53,8 +53,20 @@
  * 分层:本模块不值 import `server.ts`(那条边闭合运行时装载环),只 `import type`。
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
-import type { RouteCtx } from "../route-ctx.js";
+import type { RouteCtx, RouteMatch, RouteIdsOf } from "../route-ctx.js";
 export declare const MEMORY_CONSOLIDATION_STATUS_PATH = "/v1/admin/memory/consolidation";
 export declare const MEMORY_CONSOLIDATION_RUN_PATH = "/v1/admin/memory/consolidation/run";
-export declare function handleMemoryConsolidation(req: IncomingMessage, res: ServerResponse, url: string, ctx: RouteCtx): Promise<boolean>;
+export declare function handleMemoryConsolidation(req: IncomingMessage, res: ServerResponse, match: RouteMatch<MemoryConsolidationRouteId>, ctx: RouteCtx): Promise<void>;
+export declare const MEMORY_CONSOLIDATION_ROUTES: readonly [{
+    readonly id: "memory-consolidation-run";
+    readonly path: "/v1/admin/memory/consolidation/run";
+    readonly billable: true;
+    readonly methods: readonly ["POST"];
+}, {
+    readonly id: "memory-consolidation-status";
+    readonly path: "/v1/admin/memory/consolidation";
+    readonly methods: readonly ["GET"];
+}];
+/** 本域可分派行的 `id` 闭集 —— handler 的 `switch` 按它判穷尽(漏一口 = 编译红)。 */
+export type MemoryConsolidationRouteId = RouteIdsOf<typeof MEMORY_CONSOLIDATION_ROUTES>;
 //# sourceMappingURL=memory-consolidation.d.ts.map

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

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { ControlPlaneCorruptError } from "@sema-agent/core";
 import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal } from "../principal-gate.js";
+import { assertNever } from "../route-ctx.js";
 export const MEMORY_CONSOLIDATION_STATUS_PATH = "/v1/admin/memory/consolidation";
 export const MEMORY_CONSOLIDATION_RUN_PATH = "/v1/admin/memory/consolidation/run";
 const RunRequestSchema = z.object({ scope: z.string().optional() }).strict();
@@ -69,21 +70,9 @@ function codeOf(err) {
     const { code } = err;
     return typeof code === "string" ? code : undefined;
 }
-export async function handleMemoryConsolidation(req, res, url, ctx) {
-    const miss = { fell: false };
-    await handleMemoryConsolidationBody(req, res, url, ctx, miss);
-    return !miss.fell;
-}
-async function handleMemoryConsolidationBody(req, res, url, ctx, miss) {
+export async function handleMemoryConsolidation(req, res, match, ctx) {
     const { deps } = ctx;
-    const path = url.split("?")[0] ?? url;
-    const isRun = req.method === "POST" && path === MEMORY_CONSOLIDATION_RUN_PATH;
-    const isStatus = req.method === "GET" && path === MEMORY_CONSOLIDATION_STATUS_PATH;
     const faces = deps.memoryConsolidation;
-    if ((!isRun && !isStatus) || faces === undefined) {
-        miss.fell = true;
-        return;
-    }
     const principal = gatedPrincipal(req, deps.config);
     if (deps.config.requirePrincipal && !principal) {
         sendPrincipalRefusal(res, req, deps.config);
@@ -93,63 +82,74 @@ async function handleMemoryConsolidationBody(req, res, url, ctx, miss) {
         sendError(res, 403, "auth.operator_only", "memory consolidation is operator-only: the caller principal is not in OPERATOR_PRINCIPALS (an empty list means NO one is an operator — configure it to enable these endpoints)");
         return;
     }
-    if (isStatus) {
-        const q = new URL(req.url ?? "", "http://x").searchParams.get("scope") ?? undefined;
-        const decided = decideScope(q, faces.scopes);
-        const scope = "scope" in decided ? decided.scope : undefined;
-        const row = scope !== undefined ? faces.lastRun(scope) : undefined;
-        sendJson(res, 200, {
-            enabled: true,
-            seat: faces.seat,
-            model: faces.model,
-            scopes: faces.scopes,
-            ...(scope !== undefined ? { scope } : {}),
-            ...(row !== undefined ? { lastRun: buildRunRowSummary(row) } : {}),
-        });
-        return;
-    }
-    const parsed = RunRequestSchema.safeParse(await ctx.helpers.readJson(req));
-    if (!parsed.success) {
-        sendError(res, 400, "request.body_shape", "invalid memory consolidation request — expected an object with an optional `scope` string");
-        return;
-    }
-    const decided = decideScope(parsed.data.scope, faces.scopes);
-    if ("refusal" in decided) {
-        switch (decided.refusal) {
-            case "blank":
-                sendError(res, 400, "request.body_shape", "invalid memory consolidation request — `scope` must be a non-empty string naming the memory scope to fold");
-                return;
-            case "none-configured":
-                sendError(res, 400, "request.body_shape", "invalid memory consolidation request — `scope` is required: this deployment configured no MEMORY_CONSOLIDATION_SCOPES, so there is no single library to default to, and one consolidation run reads a WHOLE scope (~1e5 prompt tokens). Send a `scope`, or set MEMORY_CONSOLIDATION_SCOPES to the one scope this worker folds");
-                return;
-            case "off-roster":
-                sendError(res, 400, "request.body_shape", `invalid memory consolidation request — this worker declares the scopes it folds in MEMORY_CONSOLIDATION_SCOPES (${faces.scopes.join(", ")}) and the requested scope is not one of them; a stale or mistyped scope would spend a whole-library distillation on a different library and supersede its entries. Send one of the declared scopes, add this one to MEMORY_CONSOLIDATION_SCOPES, or unset that knob to fold any scope on request`);
-                return;
-            case "ambiguous":
-                sendError(res, 400, "request.body_shape", `invalid memory consolidation request — a scope is required: MEMORY_CONSOLIDATION_SCOPES lists more than one scope (${faces.scopes.join(", ")}) and the server never picks which library to spend a whole-library distillation on`);
-                return;
-            default: {
-                const unreachable = decided.refusal;
-                throw new Error(`unhandled consolidation scope refusal: ${String(unreachable)}`);
-            }
-        }
-    }
-    try {
-        const r = await faces.run(decided.scope);
-        sendJson(res, 200, buildRunSummary(r));
-    }
-    catch (err) {
-        const coreCode = codeOf(err);
-        if (coreCode !== undefined) {
-            sendError(res, 409, "memory.consolidation_refused", `memory consolidation refused (${coreCode}): ${err instanceof Error ? err.message : String(err)}`);
+    switch (match.decl.id) {
+        case "memory-consolidation-status": {
+            const q = new URLSearchParams(match.search).get("scope") ?? undefined;
+            const decided = decideScope(q, faces.scopes);
+            const scope = "scope" in decided ? decided.scope : undefined;
+            const row = scope !== undefined ? faces.lastRun(scope) : undefined;
+            sendJson(res, 200, {
+                enabled: true,
+                seat: faces.seat,
+                model: faces.model,
+                scopes: faces.scopes,
+                ...(scope !== undefined ? { scope } : {}),
+                ...(row !== undefined ? { lastRun: buildRunRowSummary(row) } : {}),
+            });
             return;
         }
-        if (err instanceof ControlPlaneCorruptError) {
-            sendError(res, 500, "internal.memory_control_plane_corrupt", err.message);
+        case "memory-consolidation-run": {
+            const parsed = RunRequestSchema.safeParse(await ctx.helpers.readJson(req));
+            if (!parsed.success) {
+                sendError(res, 400, "request.body_shape", "invalid memory consolidation request — expected an object with an optional `scope` string");
+                return;
+            }
+            const decided = decideScope(parsed.data.scope, faces.scopes);
+            if ("refusal" in decided) {
+                switch (decided.refusal) {
+                    case "blank":
+                        sendError(res, 400, "request.body_shape", "invalid memory consolidation request — `scope` must be a non-empty string naming the memory scope to fold");
+                        return;
+                    case "none-configured":
+                        sendError(res, 400, "request.body_shape", "invalid memory consolidation request — `scope` is required: this deployment configured no MEMORY_CONSOLIDATION_SCOPES, so there is no single library to default to, and one consolidation run reads a WHOLE scope (~1e5 prompt tokens). Send a `scope`, or set MEMORY_CONSOLIDATION_SCOPES to the one scope this worker folds");
+                        return;
+                    case "off-roster":
+                        sendError(res, 400, "request.body_shape", `invalid memory consolidation request — this worker declares the scopes it folds in MEMORY_CONSOLIDATION_SCOPES (${faces.scopes.join(", ")}) and the requested scope is not one of them; a stale or mistyped scope would spend a whole-library distillation on a different library and supersede its entries. Send one of the declared scopes, add this one to MEMORY_CONSOLIDATION_SCOPES, or unset that knob to fold any scope on request`);
+                        return;
+                    case "ambiguous":
+                        sendError(res, 400, "request.body_shape", `invalid memory consolidation request — a scope is required: MEMORY_CONSOLIDATION_SCOPES lists more than one scope (${faces.scopes.join(", ")}) and the server never picks which library to spend a whole-library distillation on`);
+                        return;
+                    default: {
+                        const unreachable = decided.refusal;
+                        throw new Error(`unhandled consolidation scope refusal: ${String(unreachable)}`);
+                    }
+                }
+            }
+            try {
+                const r = await faces.run(decided.scope);
+                sendJson(res, 200, buildRunSummary(r));
+            }
+            catch (err) {
+                const coreCode = codeOf(err);
+                if (coreCode !== undefined) {
+                    sendError(res, 409, "memory.consolidation_refused", `memory consolidation refused (${coreCode}): ${err instanceof Error ? err.message : String(err)}`);
+                    return;
+                }
+                if (err instanceof ControlPlaneCorruptError) {
+                    sendError(res, 500, "internal.memory_control_plane_corrupt", err.message);
+                    return;
+                }
+                ctx.deps.logger?.warn?.("memory_consolidation_run_failed", { scope: decided.scope, err: String(err) });
+                sendError(res, 500, "internal.error", "memory consolidation run failed");
+            }
             return;
         }
-        ctx.deps.logger?.warn?.("memory_consolidation_run_failed", { scope: decided.scope, err: String(err) });
-        sendError(res, 500, "internal.error", "memory consolidation run failed");
+        default:
+            return assertNever(match.decl.id);
     }
 }
+export const MEMORY_CONSOLIDATION_ROUTES = [
+    { id: "memory-consolidation-run", path: MEMORY_CONSOLIDATION_RUN_PATH, billable: true, methods: ["POST"] },
+    { id: "memory-consolidation-status", path: MEMORY_CONSOLIDATION_STATUS_PATH, methods: ["GET"] },
+];
 //# sourceMappingURL=memory-consolidation.js.map

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

@@ -79,11 +79,9 @@
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { type OriginClearanceRow } from "@sema-agent/core";
-import type { RouteCtx } from "../route-ctx.js";
+import type { RouteCtx, RouteMatch, RouteIdsOf } from "../route-ctx.js";
 export declare const MEMORY_ORIGIN_EXTERNAL_PATH = "/v1/memory/origin/external";
 export declare const MEMORY_ORIGIN_CLEARANCES_PATH = "/v1/memory/origin/clearances";
-/** 带参写口 ⇒ 路由声明表(`http/route-table.ts`)里走 `pattern` 行,不是 `path` 行。 */
-export declare const MEMORY_ORIGIN_CLEAR_RE: RegExp;
 /**
  * 一条清标行 → wire 的**显式白名单**(F-7)。全文理由见文件头「为什么是白名单」。
  *
@@ -120,5 +118,26 @@ export declare function buildClearanceRowWire(r: OriginClearanceRow): {
         taint: "external";
     };
 };
-export declare function handleMemoryOrigin(req: IncomingMessage, res: ServerResponse, url: string, ctx: RouteCtx): Promise<boolean>;
+export declare function handleMemoryOrigin(req: IncomingMessage, res: ServerResponse, match: RouteMatch<MemoryOriginRouteId>, ctx: RouteCtx): Promise<void>;
+export declare const MEMORY_ORIGIN_ROUTES: readonly [{
+    readonly id: "memory-origin-external";
+    readonly path: "/v1/memory/origin/external";
+    readonly credentialGated: readonly ["GET"];
+    readonly methods: readonly ["GET"];
+}, {
+    readonly id: "memory-origin-clearances";
+    readonly path: "/v1/memory/origin/clearances";
+    readonly credentialGated: readonly ["GET"];
+    readonly methods: readonly ["GET"];
+}, {
+    readonly id: "memory-origin-entry-clear";
+    readonly pattern: RegExp;
+    readonly label: "/v1/memory/origin/entries/:entryId/clear";
+    readonly methods: readonly ["POST"];
+}, {
+    readonly prefix: "/v1/memory/origin/entries/";
+    readonly credentialGated: readonly ["POST"];
+}];
+/** 本域可分派行的 `id` 闭集 —— handler 的 `switch` 按它判穷尽(漏一口 = 编译红)。 */
+export type MemoryOriginRouteId = RouteIdsOf<typeof MEMORY_ORIGIN_ROUTES>;
 //# sourceMappingURL=memory-origin.d.ts.map