loki-mode 10.8.0 → 10.9.1

package/packages/control-plane/src/server/legacy/routes-audit.ts

@@ -0,0 +1,50 @@
+// CPE24-P2: legacy (port 57374) mappings for audit and checkpoints. Reads share their implementation with routes/checkpoints.ts; the two POSTs
+// keep the /v1 rule (loopback peer, loopback Host, JSON) even though the shim guard already passed, so a token alone never reaches a restore.
+import type { Context } from "hono";
+import type { Db } from "../../db/migrate.ts";
+import { audit } from "../audit.ts";
+import { isLoopbackHost, peerIsLoopback } from "../auth.ts";
+import { auditSummary, createCheckpoint, getCheckpoint, listCheckpoints, parseDays, parseLimit, rollbackCheckpoint, validCheckpointId } from "../routes/checkpoints.ts";
+
+type AuditList = (c: Context) => { err: Response; rows?: undefined } | { err?: undefined; rows: unknown[] };
+
+const BAD_ID = "Invalid checkpoint_id: must be 1-128 chars of alphanumeric, hyphens, and underscores";
+
+export function auditCheckpointMapped(db: Db, repoDir: string, auditList: AuditList): Record<string, (c: Context) => Response | Promise<Response>> {
+  const local = (c: Context) => peerIsLoopback(c) && isLoopbackHost(c.req.header("host")) && (c.req.header("content-type") ?? "").toLowerCase().startsWith("application/json");
+  const refuse = (c: Context) => c.json({ detail: "loopback JSON requests only" }, 403);
+  return {
+    "GET /api/enterprise/audit": (c) => { const r = auditList(c); return r.err ?? c.json(r.rows); },
+    "GET /api/enterprise/audit/summary": (c) => c.json(auditSummary(db, parseDays(c.req.query("days")))),
+    "GET /api/checkpoints": (c) => c.json(listCheckpoints(repoDir, parseLimit(c.req.query("limit")))),
+    "GET /api/checkpoints/{checkpoint_id}": (c) => {
+      const id = c.req.param("checkpoint_id") ?? "";
+      if (!validCheckpointId(id)) return c.json({ detail: BAD_ID }, 400);
+      const m = getCheckpoint(repoDir, id);
+      return m ? c.json(m) : c.json({ detail: "Checkpoint not found" }, 404);
+    },
+    "POST /api/checkpoints": async (c) => {
+      if (!local(c)) return refuse(c);
+      const body = (await c.req.json().catch(() => ({}))) as { message?: unknown };
+      const message = typeof body?.message === "string" ? body.message : "";
+      if (message.length > 500) return c.json({ detail: "message must be at most 500 characters" }, 422);
+      try {
+        const meta = createCheckpoint(repoDir, message);
+        audit(db, { kind: "checkpoint.create", target: String(meta.id), result: "ok", detail: "legacy route" });
+        return c.json(meta, 201);
+      } catch (e) {
+        audit(db, { kind: "checkpoint.create", result: "error", detail: (e as Error).message });
+        return c.json({ detail: "could not create the checkpoint" }, 500);
+      }
+    },
+    "POST /api/checkpoints/{checkpoint_id}/rollback": (c) => {
+      if (!local(c)) return refuse(c);
+      const id = c.req.param("checkpoint_id") ?? "";
+      if (!validCheckpointId(id)) { audit(db, { kind: "checkpoint.rollback", target: id.slice(0, 128), result: "refused", detail: "invalid id (legacy route)" }); return c.json({ detail: BAD_ID }, 400); }
+      const r = rollbackCheckpoint(repoDir, id);
+      if (!r) { audit(db, { kind: "checkpoint.rollback", target: id, result: "refused", detail: "not found (legacy route)" }); return c.json({ detail: "Checkpoint not found" }, 404); }
+      audit(db, { kind: "checkpoint.rollback", target: id, result: r.errors.length ? "partial" : "ok", detail: `restored ${r.restored}; pre-rollback snapshot ${r.pre_rollback_snapshot} (legacy route)` });
+      return c.json({ ...r, message: `Restored ${r.restored} item(s) from ${id}. Prior state saved as ${r.pre_rollback_snapshot} (undo this rollback by restoring it).` });
+    },
+  };
+}

package/packages/control-plane/src/server/legacy/routes-control.ts

@@ -0,0 +1,26 @@
+// CPE24-P4: legacy (port 57374) mappings for session control and the Completion Council. They share the /v1 implementation in
+// routes/session_control.ts (fixed action enum, signal files only, same-origin check, audit row). The shim guard (CP token or loopback peer) has already run.
+import type { Context } from "hono";
+import type { Db } from "../../db/migrate.ts";
+import { councilConvergence, councilReport, councilState, councilTranscripts, councilVerdicts, intQ, runControl } from "../routes/session_control.ts";
+import { lokiDirOf } from "../routes/cost_ledger.ts";
+
+export function controlMapped(db: Db, repoDir: string): Record<string, (c: Context) => Response> {
+  const loki = () => lokiDirOf(repoDir);
+  return {
+    "POST /api/control/pause": (c) => runControl(db, repoDir, "pause", c, "legacy"),
+    "POST /api/control/resume": (c) => runControl(db, repoDir, "resume", c, "legacy"),
+    "POST /api/control/stop": (c) => runControl(db, repoDir, "stop", c, "legacy"),
+    "POST /api/council/force-review": (c) => runControl(db, repoDir, "council-review", c, "legacy"),
+    "GET /api/council/state": (c) => c.json(councilState(loki())),
+    "GET /api/council/verdicts": (c) => { const n = intQ(c.req.query("limit"), 1000); return n === null || n === 0 ? c.json({ detail: "limit must be 1..1000" }, 422) : c.json(councilVerdicts(loki(), n)); },
+    "GET /api/council/convergence": (c) => c.json(councilConvergence(loki())),
+    "GET /api/council/report": (c) => c.json(councilReport(loki())),
+    "GET /api/council/transcripts": (c) => {
+      const limit = intQ(c.req.query("limit"), 200), iterMin = intQ(c.req.query("iter_min"), Number.MAX_SAFE_INTEGER);
+      if (limit === null || limit === 0 || iterMin === null) return c.json({ detail: "limit must be 1..200 and iter_min a non-negative integer" }, 422);
+      const r = councilTranscripts(loki(), { limit, since: c.req.query("since"), iter_min: iterMin });
+      return "error" in r ? c.json({ detail: r.error }, 400) : c.json(r);
+    },
+  };
+}

package/packages/control-plane/src/server/legacy/routes-memory.ts

@@ -0,0 +1,30 @@
+// CPE24-P3: legacy (port 57374) mappings for memory, context, focus and tasks. Each reads the same source as its /v1 route (routes/memory.ts)
+// and keeps the legacy response shape. The shim's guard (legacyGuard) has already run; POST /api/focus adds the same loopback, JSON and Origin checks as /v1/focus.
+import type { Context } from "hono";
+import { contextTracking, focusInfo, lokiFor, memoryEconomics, memoryEpisode, memoryEpisodes, memoryPatterns, memorySkills, mutationAllowed, setFocus, tasksList } from "../routes/memory.ts";
+
+export function memoryMapped(repoDir: string): Record<string, (c: Context) => Response | Promise<Response>> {
+  const loki = () => lokiFor(repoDir);
+  return {
+    "GET /api/tasks": (c) => {
+      if (c.req.query("project_id") !== undefined) return c.json({ detail: "project_id filter is not supported by the Control Plane" }, 400);
+      return c.json(tasksList(loki(), c.req.query("status")));
+    },
+    "GET /api/memory/episodes": (c) => {
+      const lim = c.req.query("limit") === undefined ? 50 : Number(c.req.query("limit"));
+      return Number.isInteger(lim) && lim >= 1 && lim <= 1000 ? c.json(memoryEpisodes(loki(), lim)) : c.json({ detail: "limit must be 1..1000" }, 422);
+    },
+    "GET /api/memory/episodes/{episode_id}": (c) => { const e = memoryEpisode(loki(), c.req.param("episode_id") ?? ""); return e ? c.json(e) : c.json({ detail: "Episode not found" }, 404); },
+    "GET /api/memory/patterns": (c) => c.json(memoryPatterns(loki())),
+    "GET /api/memory/patterns/{pattern_id}": (c) => { const p = memoryPatterns(loki()).find((x) => x.id === c.req.param("pattern_id")); return p ? c.json(p) : c.json({ detail: "Pattern not found" }, 404); },
+    "GET /api/memory/skills": (c) => c.json(memorySkills(loki())),
+    "GET /api/memory/economics": (c) => c.json(memoryEconomics(loki())),
+    "GET /api/context": (c) => { const r = contextTracking(loki()); return c.json(r.body, r.status); },
+    "POST /api/focus": async (c) => {
+      if (!mutationAllowed(c)) return c.json({ detail: "loopback JSON requests only" }, 403);
+      const body = await c.req.json().catch(() => null);
+      const r = setFocus(repoDir, typeof body === "object" && body !== null ? (body as Record<string, unknown>).project_dir : undefined);
+      return r.ok ? c.json(focusInfo(repoDir)) : c.json({ detail: r.error }, 400);
+    },
+  };
+}

package/packages/control-plane/src/server/legacy/routes.ts

@@ -8,11 +8,11 @@ export const LEGACY_ROUTES: readonly LegacyRoute[] = [
   { method: "GET", path: "/docs", action: "410", open: true, migrate: "" },
   { method: "GET", path: "/docs/oauth2-redirect", action: "410", open: true, migrate: "" },
   { method: "GET", path: "/redoc", action: "410", open: true, migrate: "" },
-  { method: "POST", path: "/api/v2/tenants", action: "501", open: false, migrate: "" },
-  { method: "GET", path: "/api/v2/tenants", action: "501", open: false, migrate: "" },
-  { method: "GET", path: "/api/v2/tenants/{tenant_id}", action: "501", open: false, migrate: "" },
+  { method: "POST", path: "/api/v2/tenants", action: "410", open: false, migrate: "no tenants: local single user" },
+  { method: "GET", path: "/api/v2/tenants", action: "410", open: false, migrate: "no tenants: local single user" },
+  { method: "GET", path: "/api/v2/tenants/{tenant_id}", action: "410", open: false, migrate: "no tenants: local single user" },
   { method: "PUT", path: "/api/v2/tenants/{tenant_id}", action: "410", open: false, migrate: "" },
-  { method: "DELETE", path: "/api/v2/tenants/{tenant_id}", action: "501", open: false, migrate: "" },
+  { method: "DELETE", path: "/api/v2/tenants/{tenant_id}", action: "410", open: false, migrate: "no tenants: local single user" },
   { method: "GET", path: "/api/v2/tenants/{tenant_id}/projects", action: "410", open: false, migrate: "" },
   { method: "POST", path: "/api/v2/runs", action: "501", open: false, migrate: "" },
   { method: "GET", path: "/api/v2/runs", action: "map", open: false, migrate: "/v1/runs" },
@@ -20,12 +20,12 @@ export const LEGACY_ROUTES: readonly LegacyRoute[] = [
   { method: "POST", path: "/api/v2/runs/{run_id}/cancel", action: "501", open: false, migrate: "" },
   { method: "POST", path: "/api/v2/runs/{run_id}/replay", action: "501", open: false, migrate: "" },
   { method: "GET", path: "/api/v2/runs/{run_id}/timeline", action: "map", open: false, migrate: "/v1/runs/:id" },
-  { method: "POST", path: "/api/v2/api-keys", action: "501", open: false, migrate: "" },
-  { method: "GET", path: "/api/v2/api-keys", action: "501", open: false, migrate: "" },
+  { method: "POST", path: "/api/v2/api-keys", action: "410", open: false, migrate: "CP bearer token set by env (LOKI_CONTROL_TOKEN)" },
+  { method: "GET", path: "/api/v2/api-keys", action: "410", open: false, migrate: "CP bearer token set by env (LOKI_CONTROL_TOKEN)" },
   { method: "GET", path: "/api/v2/api-keys/{identifier}", action: "410", open: false, migrate: "" },
   { method: "PUT", path: "/api/v2/api-keys/{identifier}", action: "410", open: false, migrate: "" },
-  { method: "DELETE", path: "/api/v2/api-keys/{identifier}", action: "501", open: false, migrate: "" },
-  { method: "POST", path: "/api/v2/api-keys/{identifier}/rotate", action: "501", open: false, migrate: "" },
+  { method: "DELETE", path: "/api/v2/api-keys/{identifier}", action: "410", open: false, migrate: "CP bearer token set by env (LOKI_CONTROL_TOKEN)" },
+  { method: "POST", path: "/api/v2/api-keys/{identifier}/rotate", action: "410", open: false, migrate: "CP bearer token set by env (LOKI_CONTROL_TOKEN)" },
   { method: "GET", path: "/api/v2/policies", action: "410", open: false, migrate: "" },
   { method: "PUT", path: "/api/v2/policies", action: "410", open: false, migrate: "" },
   { method: "POST", path: "/api/v2/policies/evaluate", action: "410", open: false, migrate: "" },
@@ -61,31 +61,31 @@ export const LEGACY_ROUTES: readonly LegacyRoute[] = [
   { method: "GET", path: "/api/projects/{project_id}", action: "501", open: false, migrate: "" },
   { method: "PUT", path: "/api/projects/{project_id}", action: "501", open: false, migrate: "" },
   { method: "DELETE", path: "/api/projects/{project_id}", action: "501", open: false, migrate: "" },
-  { method: "GET", path: "/api/tasks", action: "501", open: false, migrate: "" },
-  { method: "POST", path: "/api/tasks", action: "501", open: false, migrate: "" },
-  { method: "GET", path: "/api/tasks/{task_id}", action: "501", open: false, migrate: "" },
-  { method: "PUT", path: "/api/tasks/{task_id}", action: "501", open: false, migrate: "" },
-  { method: "DELETE", path: "/api/tasks/{task_id}", action: "501", open: false, migrate: "" },
-  { method: "POST", path: "/api/tasks/{task_id}/move", action: "501", open: false, migrate: "" },
-  { method: "WS", path: "/ws", action: "501", open: true, migrate: "" },
+  { method: "GET", path: "/api/tasks", action: "map", open: false, migrate: "/v1/tasks" },
+  { method: "POST", path: "/api/tasks", action: "410", open: false, migrate: "no v10 task queue; read-only GET /v1/tasks" },
+  { method: "GET", path: "/api/tasks/{task_id}", action: "410", open: false, migrate: "no v10 task queue; read-only GET /v1/tasks" },
+  { method: "PUT", path: "/api/tasks/{task_id}", action: "410", open: false, migrate: "no v10 task queue; read-only GET /v1/tasks" },
+  { method: "DELETE", path: "/api/tasks/{task_id}", action: "410", open: false, migrate: "no v10 task queue; read-only GET /v1/tasks" },
+  { method: "POST", path: "/api/tasks/{task_id}/move", action: "410", open: false, migrate: "no v10 task queue; read-only GET /v1/tasks" },
+  { method: "WS", path: "/ws", action: "410", open: true, migrate: "SSE at GET /v1/stream" },
   { method: "GET", path: "/api/registry/projects", action: "410", open: false, migrate: "" },
-  { method: "POST", path: "/api/registry/projects", action: "501", open: false, migrate: "" },
+  { method: "POST", path: "/api/registry/projects", action: "410", open: false, migrate: "repos are discovered locally; GET /v1/repos" },
   { method: "GET", path: "/api/registry/projects/{identifier}", action: "410", open: false, migrate: "" },
   { method: "DELETE", path: "/api/registry/projects/{identifier}", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/registry/projects/{identifier}/health", action: "410", open: false, migrate: "" },
   { method: "POST", path: "/api/registry/projects/{identifier}/access", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/registry/discover", action: "410", open: false, migrate: "" },
-  { method: "POST", path: "/api/registry/sync", action: "501", open: false, migrate: "" },
+  { method: "POST", path: "/api/registry/sync", action: "410", open: false, migrate: "repos are discovered locally; GET /v1/repos" },
   { method: "GET", path: "/api/registry/tasks", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/registry/learnings", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/fleet/runs", action: "map", open: false, migrate: "/v1/fleet/runs" },
   { method: "GET", path: "/api/fleet/summary", action: "map", open: false, migrate: "/v1/fleet/summary" },
   { method: "GET", path: "/api/fleet/runs/{identifier}", action: "410", open: false, migrate: "" },
-  { method: "POST", path: "/api/focus", action: "501", open: false, migrate: "" },
+  { method: "POST", path: "/api/focus", action: "map", open: false, migrate: "/v1/focus" },
   { method: "GET", path: "/api/focus", action: "410", open: false, migrate: "" },
   { method: "DELETE", path: "/api/focus", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/session/model", action: "410", open: false, migrate: "" },
-  { method: "POST", path: "/api/session/model", action: "501", open: false, migrate: "" },
+  { method: "POST", path: "/api/session/model", action: "410", open: false, migrate: "no mid-run model switch; start a new run with another model (POST /v1/runs)" },
   { method: "GET", path: "/api/running-projects", action: "410", open: false, migrate: "" },
   { method: "POST", path: "/api/control/start", action: "501", open: false, migrate: "" },
   { method: "GET", path: "/api/control/builds/{execution_id}", action: "410", open: false, migrate: "" },
@@ -99,19 +99,19 @@ export const LEGACY_ROUTES: readonly LegacyRoute[] = [
   { method: "POST", path: "/api/enterprise/tokens", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/enterprise/tokens", action: "410", open: false, migrate: "" },
   { method: "DELETE", path: "/api/enterprise/tokens/{identifier}", action: "410", open: false, migrate: "" },
-  { method: "GET", path: "/api/enterprise/audit", action: "410", open: false, migrate: "" },
-  { method: "GET", path: "/api/enterprise/audit/summary", action: "410", open: false, migrate: "" },
+  { method: "GET", path: "/api/enterprise/audit", action: "map", open: false, migrate: "/v1/audit" },
+  { method: "GET", path: "/api/enterprise/audit/summary", action: "map", open: false, migrate: "/v1/audit/summary" },
   { method: "GET", path: "/api/compliance", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/memory/summary", action: "410", open: false, migrate: "" },
-  { method: "GET", path: "/api/memory/episodes", action: "501", open: false, migrate: "" },
-  { method: "GET", path: "/api/memory/episodes/{episode_id}", action: "501", open: false, migrate: "" },
-  { method: "GET", path: "/api/memory/patterns", action: "501", open: false, migrate: "" },
-  { method: "GET", path: "/api/memory/patterns/{pattern_id}", action: "501", open: false, migrate: "" },
-  { method: "GET", path: "/api/memory/skills", action: "501", open: false, migrate: "" },
+  { method: "GET", path: "/api/memory/episodes", action: "map", open: false, migrate: "/v1/memory/episodes" },
+  { method: "GET", path: "/api/memory/episodes/{episode_id}", action: "map", open: false, migrate: "/v1/memory/episodes/{id}" },
+  { method: "GET", path: "/api/memory/patterns", action: "map", open: false, migrate: "/v1/memory/patterns" },
+  { method: "GET", path: "/api/memory/patterns/{pattern_id}", action: "map", open: false, migrate: "/v1/memory/patterns/{id}" },
+  { method: "GET", path: "/api/memory/skills", action: "map", open: false, migrate: "/v1/memory/skills" },
   { method: "GET", path: "/api/memory/skills/{skill_id}", action: "410", open: false, migrate: "" },
-  { method: "GET", path: "/api/memory/economics", action: "501", open: false, migrate: "" },
-  { method: "POST", path: "/api/memory/consolidate", action: "501", open: false, migrate: "" },
-  { method: "POST", path: "/api/memory/retrieve", action: "501", open: false, migrate: "" },
+  { method: "GET", path: "/api/memory/economics", action: "map", open: false, migrate: "/v1/memory/economics" },
+  { method: "POST", path: "/api/memory/consolidate", action: "410", open: false, migrate: "read-only GET /v1/memory/*" },
+  { method: "POST", path: "/api/memory/retrieve", action: "410", open: false, migrate: "read-only GET /v1/memory/*" },
   { method: "GET", path: "/api/memory/index", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/memory/timeline", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/memory/files", action: "410", open: false, migrate: "" },
@@ -122,41 +122,41 @@ export const LEGACY_ROUTES: readonly LegacyRoute[] = [
   { method: "GET", path: "/api/learning/trends", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/learning/signals", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/learning/aggregation", action: "410", open: false, migrate: "" },
-  { method: "POST", path: "/api/learning/aggregate", action: "501", open: false, migrate: "" },
+  { method: "POST", path: "/api/learning/aggregate", action: "410", open: false, migrate: "read-only GET /v1/memory/patterns" },
   { method: "GET", path: "/api/learning/preferences", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/learning/errors", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/learning/success", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/learning/tools", action: "410", open: false, migrate: "" },
-  { method: "POST", path: "/api/control/pause", action: "501", open: false, migrate: "" },
-  { method: "POST", path: "/api/control/resume", action: "501", open: false, migrate: "" },
-  { method: "POST", path: "/api/control/stop", action: "501", open: false, migrate: "" },
+  { method: "POST", path: "/api/control/pause", action: "map", open: false, migrate: "/v1/control/pause" },
+  { method: "POST", path: "/api/control/resume", action: "map", open: false, migrate: "/v1/control/resume" },
+  { method: "POST", path: "/api/control/stop", action: "map", open: false, migrate: "/v1/control/stop" },
   { method: "GET", path: "/api/cost", action: "map", open: false, migrate: "/v1/cost/snapshot" },
   { method: "GET", path: "/api/budget", action: "501", open: false, migrate: "" },
   { method: "GET", path: "/api/cost/timeline", action: "map", open: false, migrate: "/v1/cost/timeline" },
   { method: "GET", path: "/api/trust/trajectory", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/gate-policy", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/pricing", action: "410", open: false, migrate: "" },
-  { method: "GET", path: "/api/council/state", action: "410", open: false, migrate: "" },
-  { method: "GET", path: "/api/council/verdicts", action: "410", open: false, migrate: "" },
-  { method: "GET", path: "/api/council/convergence", action: "410", open: false, migrate: "" },
-  { method: "GET", path: "/api/council/report", action: "410", open: false, migrate: "" },
-  { method: "POST", path: "/api/council/force-review", action: "501", open: false, migrate: "" },
-  { method: "GET", path: "/api/council/transcripts", action: "501", open: false, migrate: "" },
+  { method: "GET", path: "/api/council/state", action: "map", open: false, migrate: "/v1/council/state" },
+  { method: "GET", path: "/api/council/verdicts", action: "map", open: false, migrate: "/v1/council/verdicts" },
+  { method: "GET", path: "/api/council/convergence", action: "map", open: false, migrate: "/v1/council/convergence" },
+  { method: "GET", path: "/api/council/report", action: "map", open: false, migrate: "/v1/council/report" },
+  { method: "POST", path: "/api/council/force-review", action: "map", open: false, migrate: "/v1/control/council-review" },
+  { method: "GET", path: "/api/council/transcripts", action: "map", open: false, migrate: "/v1/council/transcripts" },
   { method: "GET", path: "/api/council/transcripts/{iteration_id}", action: "410", open: false, migrate: "" },
-  { method: "GET", path: "/api/context", action: "501", open: false, migrate: "" },
+  { method: "GET", path: "/api/context", action: "map", open: false, migrate: "/v1/context" },
   { method: "GET", path: "/api/notifications", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/notifications/triggers", action: "410", open: false, migrate: "" },
-  { method: "PUT", path: "/api/notifications/triggers", action: "501", open: false, migrate: "" },
+  { method: "PUT", path: "/api/notifications/triggers", action: "410", open: false, migrate: "GET /v1/notifications (derived from events)" },
   { method: "POST", path: "/api/notifications/{notification_id}/acknowledge", action: "410", open: false, migrate: "" },
   { method: "POST", path: "/api/notifications/{notification_id}/unacknowledge", action: "410", open: false, migrate: "" },
-  { method: "GET", path: "/api/checkpoints", action: "501", open: false, migrate: "" },
-  { method: "GET", path: "/api/checkpoints/{checkpoint_id}", action: "410", open: false, migrate: "" },
-  { method: "POST", path: "/api/checkpoints", action: "501", open: false, migrate: "" },
-  { method: "POST", path: "/api/checkpoints/{checkpoint_id}/rollback", action: "501", open: false, migrate: "" },
+  { method: "GET", path: "/api/checkpoints", action: "map", open: false, migrate: "/v1/checkpoints" },
+  { method: "GET", path: "/api/checkpoints/{checkpoint_id}", action: "map", open: false, migrate: "/v1/checkpoints/{id}" },
+  { method: "POST", path: "/api/checkpoints", action: "map", open: false, migrate: "/v1/checkpoints" },
+  { method: "POST", path: "/api/checkpoints/{checkpoint_id}/rollback", action: "map", open: false, migrate: "/v1/checkpoints/{id}/rollback" },
   { method: "GET", path: "/api/agents", action: "410", open: false, migrate: "" },
-  { method: "POST", path: "/api/agents/{agent_id}/kill", action: "501", open: false, migrate: "" },
-  { method: "POST", path: "/api/agents/{agent_id}/pause", action: "501", open: false, migrate: "" },
-  { method: "POST", path: "/api/agents/{agent_id}/resume", action: "501", open: false, migrate: "" },
+  { method: "POST", path: "/api/agents/{agent_id}/kill", action: "410", open: false, migrate: "POST /v1/control/stop" },
+  { method: "POST", path: "/api/agents/{agent_id}/pause", action: "410", open: false, migrate: "POST /v1/control/stop (v10 has no pause)" },
+  { method: "POST", path: "/api/agents/{agent_id}/resume", action: "410", open: false, migrate: "POST /v1/control/resume" },
   { method: "GET", path: "/api/logs", action: "410", open: false, migrate: "" },
   { method: "POST", path: "/api/collab/join", action: "410", open: false, migrate: "" },
   { method: "POST", path: "/api/collab/leave", action: "410", open: false, migrate: "" },
@@ -185,19 +185,19 @@ export const LEGACY_ROUTES: readonly LegacyRoute[] = [
   { method: "GET", path: "/api/checklist/summary", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/prd-observations", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/checklist/waivers", action: "410", open: false, migrate: "" },
-  { method: "POST", path: "/api/checklist/waivers", action: "501", open: false, migrate: "" },
-  { method: "DELETE", path: "/api/checklist/waivers/{item_id}", action: "501", open: false, migrate: "" },
+  { method: "POST", path: "/api/checklist/waivers", action: "410", open: false, migrate: "plan.json and receipt claims in GET /v1/runs/:id" },
+  { method: "DELETE", path: "/api/checklist/waivers/{item_id}", action: "410", open: false, migrate: "plan.json and receipt claims in GET /v1/runs/:id" },
   { method: "GET", path: "/api/council/gate", action: "501", open: false, migrate: "" },
   { method: "GET", path: "/api/app-runner/status", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/app-runner/logs", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/app-runner/errors", action: "410", open: false, migrate: "" },
-  { method: "POST", path: "/api/control/app-restart", action: "501", open: false, migrate: "" },
-  { method: "POST", path: "/api/control/app-stop", action: "501", open: false, migrate: "" },
+  { method: "POST", path: "/api/control/app-restart", action: "410", open: false, migrate: "evidence in GET /v1/runs/:source/:run/artifact/*" },
+  { method: "POST", path: "/api/control/app-stop", action: "410", open: false, migrate: "evidence in GET /v1/runs/:source/:run/artifact/*" },
   { method: "GET", path: "/api/playwright/results", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/playwright/screenshot", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/failures", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/prompt-versions", action: "410", open: false, migrate: "" },
-  { method: "POST", path: "/api/prompt-optimize", action: "501", open: false, migrate: "" },
+  { method: "POST", path: "/api/prompt-optimize", action: "410", open: false, migrate: "verify stage: POST /v1/runs/:source/:run/verify" },
   { method: "GET", path: "/api/activity", action: "501", open: false, migrate: "" },
   { method: "GET", path: "/api/session-diff", action: "410", open: false, migrate: "" },
   { method: "POST", path: "/api/activity", action: "410", open: false, migrate: "" },
@@ -206,8 +206,8 @@ export const LEGACY_ROUTES: readonly LegacyRoute[] = [
   { method: "GET", path: "/", action: "308", open: false, migrate: "/" },
   { method: "GET", path: "/api/quality-score", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/quality-score/history", action: "410", open: false, migrate: "" },
-  { method: "POST", path: "/api/quality-scan", action: "501", open: false, migrate: "" },
-  { method: "GET", path: "/api/quality-report", action: "501", open: false, migrate: "" },
+  { method: "POST", path: "/api/quality-scan", action: "410", open: false, migrate: "verify stage: POST /v1/runs/:source/:run/verify" },
+  { method: "GET", path: "/api/quality-report", action: "410", open: false, migrate: "verify stage: POST /v1/runs/:source/:run/verify" },
   { method: "GET", path: "/api/migration/list", action: "501", open: false, migrate: "" },
   { method: "POST", path: "/api/migration/start", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/migration/{migration_id}/status", action: "501", open: false, migrate: "" },
@@ -216,8 +216,8 @@ export const LEGACY_ROUTES: readonly LegacyRoute[] = [
   { method: "GET", path: "/api/migration/{migration_id}/seams", action: "410", open: false, migrate: "" },
   { method: "POST", path: "/api/migration/{migration_id}/advance", action: "410", open: false, migrate: "" },
   { method: "POST", path: "/api/migration/{migration_id}/start-phase", action: "410", open: false, migrate: "" },
-  { method: "GET", path: "/api/managed/events", action: "501", open: false, migrate: "" },
-  { method: "GET", path: "/api/managed/status", action: "501", open: false, migrate: "" },
+  { method: "GET", path: "/api/managed/events", action: "410", open: false, migrate: "managed memory dropped; GET /v1/runs/:source/:run/events" },
+  { method: "GET", path: "/api/managed/status", action: "410", open: false, migrate: "managed memory dropped; GET /v1/runs" },
   { method: "GET", path: "/api/managed/memory_versions/{memory_id}", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/findings/{iteration}", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/quality/architecture", action: "410", open: false, migrate: "" },
@@ -233,5 +233,5 @@ export const LEGACY_ROUTES: readonly LegacyRoute[] = [
   { method: "GET", path: "/api/spec/history", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/wiki", action: "410", open: false, migrate: "" },
   { method: "GET", path: "/api/wiki/{section}", action: "410", open: false, migrate: "" },
-  { method: "POST", path: "/api/wiki/ask", action: "501", open: false, migrate: "" },
+  { method: "POST", path: "/api/wiki/ask", action: "410", open: false, migrate: "wiki deleted; no replacement" },
 ];

package/packages/control-plane/src/server/legacy/shim.ts

@@ -10,7 +10,10 @@ import { audit, runs } from "../../db/schema.ts";
 import { peerIsLoopback, tokenMatches } from "../auth.ts";
 import { liveInfo, listRuns, loadEvents, runDetail } from "../runs.ts";
 import { LEGACY_ROUTES, type LegacyRoute } from "./routes.ts";
+import { auditCheckpointMapped } from "./routes-audit.ts";
+import { memoryMapped } from "./routes-memory.ts";
 import { metricsMapped } from "./routes-metrics.ts";
+import { controlMapped } from "./routes-control.ts";
 
 export interface LegacyShimOpts {
   db: Db;
@@ -102,7 +105,7 @@ export function legacyShim(opts: LegacyShimOpts) {
     return { rows: queryAudit(db, { start_date: q.start_date, end_date: q.end_date, action: q.action, limit, offset }), limit, offset };
   };
 
-  const mapped: Record<string, (c: Context) => Response> = {
+  const mapped: Record<string, (c: Context) => Response | Promise<Response>> = {
     "GET /.well-known/agent.json": (c) => c.json({
       name: "Loki Mode", version, url: "https://www.autonomi.dev/",
       description: "Multi-agent autonomous system by Autonomi. Served by the Loki Control Plane.",
@@ -152,6 +155,9 @@ export function legacyShim(opts: LegacyShimOpts) {
     },
     "GET /api/v2/audit": (c) => { const r = auditList(c); return r.err ?? c.json(r.rows); },
     ...metricsMapped(opts.repoDir ?? process.cwd()),
+    ...auditCheckpointMapped(db, opts.repoDir ?? process.cwd(), auditList),
+    ...memoryMapped(opts.repoDir ?? process.cwd()),
+    ...controlMapped(db, opts.repoDir ?? process.cwd()),
   };
 
   // /lab/api/* is data, not a page: 501 JSON on every method (a 308 to the SPA would hand a client HTML). Registered before the /lab mount.
@@ -165,13 +171,13 @@ export function legacyShim(opts: LegacyShimOpts) {
     // On the CP app itself "/" is the UI already; redirecting it would loop. Only a separately mounted shim (uiBase set) redirects it.
     if (r.action === "308" && uiBase === "" && r.path === "/") continue;
     const hp = toHono(r.path);
-    const handle = (c: Context): Response => {
+    const handle = (c: Context): Response | Promise<Response> => {
       if (!r.open) { const d = denied(c); if (d) return d; }
       once(r);
       const body = { legacy_route: r.path, method: r.method };
-      if (r.action === "map") return (mapped[`${r.method} ${r.path}`] as (c: Context) => Response)(c);
+      if (r.action === "map") return (mapped[`${r.method} ${r.path}`] as (c: Context) => Response | Promise<Response>)(c);
       if (r.action === "308") return c.redirect(`${uiBase}/`, 308);
-      if (r.action === "410") return c.json({ error: "gone", detail: "This legacy dashboard route was retired; nothing consumes it.", ...body }, 410);
+      if (r.action === "410") return c.json({ error: "gone", detail: "This legacy dashboard route was retired; nothing consumes it.", ...(r.migrate ? { replacement: r.migrate } : {}), ...body }, 410);
       return c.json({ error: NOT_SUPPORTED, detail: "The legacy dashboard route exists, but the Control Plane has no data or mechanism for it yet.", ...body }, 501);
     };
     const m = r.method === "WS" || r.method === "MOUNT" ? "GET" : r.method;

package/packages/control-plane/src/server/routes/checkpoints.ts

@@ -0,0 +1,171 @@
+// CPE24-P2: checkpoints and audit summary, ported from dashboard/server.py (list/get/create/rollback checkpoint, get_audit_summary).
+// Same store as legacy and run.sh: <repo>/.loki/state/checkpoints/{index.jsonl,<id>/metadata.json}. Audit data stays read-only: nothing here
+// writes, edits or deletes an audit row or the hash chain. Create and rollback are state-changing, so they sit on `act` (loopback peer plus a
+// loopback Host plus JSON, ctx.local) like every other POST route, and each is recorded in the actions log. Unmeasured values are null, never "" or 0.
+import { execFileSync } from "node:child_process";
+import { appendFileSync, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join, sep } from "node:path";
+import { gte, sql } from "drizzle-orm";
+import type { Db } from "../../db/migrate.ts";
+import { audit as auditTable } from "../../db/schema.ts";
+import { audit } from "../audit.ts";
+import { probeAllowed, type RouteCtx } from "./index.ts";
+import { NOT_MEASURED } from "./cost_ledger.ts";
+
+type Rec = Record<string, unknown>;
+const isObj = (v: unknown): v is Rec => typeof v === "object" && v !== null && !Array.isArray(v);
+const str = (v: unknown): string | null => (typeof v === "string" && v !== "" ? v : null);
+const SAFE_ID = /^[A-Za-z0-9_-]{1,128}$/;
+const MAX_CHECKPOINTS = 50;
+
+export const validCheckpointId = (id: string) => SAFE_ID.test(id);
+const storeOf = (repoDir: string) => join(repoDir, ".loki", "state", "checkpoints");
+const lokiOf = (repoDir: string) => join(repoDir, ".loki");
+const readObj = (f: string): Rec | null => { try { const d = JSON.parse(readFileSync(f, "utf8")); return isObj(d) ? d : null; } catch { return null; } };
+const stamp = (d: Date) => d.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "").replace("T", "-");
+
+export function listCheckpoints(repoDir: string, limit = 20) {
+  const store = storeOf(repoDir);
+  let lines: string[] = [];
+  try { lines = readFileSync(join(store, "index.jsonl"), "utf8").split("\n"); } catch { return []; }
+  const out: Rec[] = [];
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let raw: unknown;
+    try { raw = JSON.parse(line); } catch { continue; }
+    if (!isObj(raw)) continue;
+    const id = String(raw.id ?? "");
+    if (!validCheckpointId(id)) continue;
+    const it = raw.iter ?? raw.iteration;
+    const cp: Rec = {
+      id, created_at: str(raw.ts) ?? str(raw.created_at) ?? str(raw.timestamp), git_sha: str(raw.sha) ?? str(raw.git_sha),
+      message: str(raw.task) ?? str(raw.message) ?? str(raw.task_description), iteration: Number.isInteger(it) ? it : null,
+    };
+    const meta = readObj(join(store, id, "metadata.json"));
+    if (meta) {
+      cp.git_branch = str(meta.git_branch); cp.provider = str(meta.provider); cp.phase = str(meta.phase);
+      cp.message ??= str(meta.task_description); cp.git_sha ??= str(meta.git_sha); cp.created_at ??= str(meta.timestamp);
+      cp.files_count = countFiles(join(store, id));
+    }
+    out.push(cp);
+  }
+  return out.reverse().slice(0, limit);
+}
+
+function countFiles(dir: string): number {
+  let n = 0;
+  const walk = (d: string, top: boolean) => {
+    for (const e of readdirSync(d, { withFileTypes: true })) {
+      if (e.isDirectory()) walk(join(d, e.name), false);
+      else if (e.isFile() && !(top && e.name === "metadata.json")) n++;
+    }
+  };
+  try { walk(dir, true); } catch { /* unreadable */ }
+  return n;
+}
+
+export function getCheckpoint(repoDir: string, id: string): Rec | null {
+  return validCheckpointId(id) ? readObj(join(storeOf(repoDir), id, "metadata.json")) : null;
+}
+
+const gitHead = (repoDir: string): string | null => {
+  try { return execFileSync("git", ["rev-parse", "HEAD"], { cwd: repoDir, timeout: 5000, stdio: ["ignore", "pipe", "ignore"] }).toString().trim() || null; } catch { return null; }
+};
+
+export function createCheckpoint(repoDir: string, message: string, now = new Date()) {
+  const store = storeOf(repoDir), loki = lokiOf(repoDir);
+  mkdirSync(store, { recursive: true });
+  const id = `chk-${stamp(now)}`, dir = join(store, id);
+  mkdirSync(dir, { recursive: true });
+  for (const f of ["dashboard-state.json", "session.json"]) { try { if (existsSync(join(loki, f))) copyFileSync(join(loki, f), join(dir, f)); } catch { /* skip */ } }
+  try { if (existsSync(join(loki, "queue"))) cpSync(join(loki, "queue"), join(dir, "queue"), { recursive: true }); } catch { /* skip */ }
+  const meta = { id, created_at: now.toISOString(), git_sha: gitHead(repoDir), message: message || null, files: readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name) };
+  writeFileSync(join(dir, "metadata.json"), JSON.stringify(meta, null, 2));
+  appendFileSync(join(store, "index.jsonl"), `${JSON.stringify(meta)}\n`);
+  // Retention: only chk- directories are ever pruned, never a rollback snapshot or a foreign directory.
+  const mine = readdirSync(store, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("chk-")).map((e) => e.name).sort();
+  while (mine.length > MAX_CHECKPOINTS) rmSync(join(store, mine.shift() as string), { recursive: true, force: true });
+  return meta;
+}
+
+/** Restore .loki/ from a checkpoint after a forced pre-rollback snapshot (so the rollback can itself be undone). Never replaces .loki/state wholesale: the store lives in it. */
+export function rollbackCheckpoint(repoDir: string, id: string, now = new Date()) {
+  const store = storeOf(repoDir), loki = lokiOf(repoDir);
+  let real = "", realStore = "";
+  try { real = realpathSync(join(store, id)); realStore = realpathSync(store); } catch { return null; }
+  if (!real.startsWith(`${realStore}${sep}`) || !statSync(real).isDirectory()) return null;
+  const preId = `rb-pre-${stamp(now)}`, pre = join(store, preId);
+  mkdirSync(pre, { recursive: true });
+  const notStore = (src: string) => src !== store; // state/ holds the store itself; never copy it into itself
+  for (const n of ["session.json", "dashboard-state.json", "CONTINUITY.md", "autonomy-state.json"]) { try { if (existsSync(join(loki, n))) copyFileSync(join(loki, n), join(pre, n)); } catch { /* skip */ } }
+  for (const d of ["state", "queue"]) { try { if (existsSync(join(loki, d))) cpSync(join(loki, d), join(pre, d), { recursive: true, filter: notStore }); } catch { /* skip */ } }
+  const preMeta = { id: preId, created_at: now.toISOString(), message: `pre-rollback snapshot (before restoring ${id})`, created_by: "control plane rollback" };
+  writeFileSync(join(pre, "metadata.json"), JSON.stringify(preMeta, null, 2));
+  appendFileSync(join(store, "index.jsonl"), `${JSON.stringify(preMeta)}\n`);
+  let restored = 0;
+  const errors: string[] = [];
+  for (const e of readdirSync(real, { withFileTypes: true })) {
+    if (e.name === "metadata.json" || e.name === "worktree-snapshot.txt") continue;
+    const src = join(real, e.name);
+    try {
+      if (lstatSync(src).isSymbolicLink()) { errors.push(`${e.name}: symlink skipped`); continue; }
+      cpSync(src, join(loki, e.name), { recursive: true, filter: (s) => s !== join(real, "state", "checkpoints") });
+      restored++;
+    } catch (err) { errors.push(`${e.name}: ${(err as Error).message}`); }
+  }
+  return { id, restored, pre_rollback_snapshot: preId, errors };
+}
+
+/** Read-only summary of the operator audit table over the last `days`. Fields the table does not record (success, resource type) are null. */
+export function auditSummary(db: Db, days: number, now = Date.now()) {
+  const since = new Date(now - days * 86_400_000).toISOString();
+  const where = gte(auditTable.ts, since);
+  const total = db.select({ n: sql<number>`count(*)` }).from(auditTable).where(where).get()?.n ?? 0;
+  const by = (col: typeof auditTable.action | typeof auditTable.actor) => Object.fromEntries(
+    db.select({ k: col, n: sql<number>`count(*)` }).from(auditTable).where(where).groupBy(col).all().map((r) => [r.k, r.n]));
+  return {
+    period_days: days, total_events: total, by_action: by(auditTable.action), by_user: by(auditTable.actor),
+    successful_events: null, failed_events: null, by_resource_type: null, recent_failures: null, not_measured: NOT_MEASURED,
+  };
+}
+
+export const parseDays = (v: string | undefined) => { const n = Number.parseInt(v ?? "7", 10); return Number.isFinite(n) && n >= 1 && n <= 3650 ? n : 7; };
+export const parseLimit = (v: string | undefined) => { const n = Number.parseInt(v ?? "20", 10); return Number.isFinite(n) ? Math.min(Math.max(n, 1), 200) : 20; };
+
+export function mount(ctx: RouteCtx): void {
+  const deny = { error: "loopback only without a token" };
+  const { app, act, db, repoDir } = ctx;
+  app.get("/v1/checkpoints", (c) => (probeAllowed(ctx, c) ? c.json({ checkpoints: listCheckpoints(repoDir, parseLimit(c.req.query("limit"))) }) : c.json(deny, 403)));
+  app.get("/v1/checkpoints/:id", (c) => {
+    if (!probeAllowed(ctx, c)) return c.json(deny, 403);
+    const id = c.req.param("id");
+    if (!validCheckpointId(id)) return c.json({ error: "invalid checkpoint id" }, 400);
+    const m = getCheckpoint(repoDir, id);
+    return m ? c.json(m) : c.json({ error: "checkpoint not found" }, 404);
+  });
+  app.get("/v1/audit/summary", (c) => (probeAllowed(ctx, c) ? c.json(auditSummary(db, parseDays(c.req.query("days")))) : c.json(deny, 403)));
+
+  act.post("/v1/checkpoints", async (c) => {
+    if (!ctx.local(c)) return c.json({ error: "loopback JSON requests only" }, 403);
+    const body = (await c.req.json().catch(() => ({}))) as Rec;
+    const message = typeof body.message === "string" ? body.message : "";
+    if (message.length > 500) return c.json({ error: "message must be at most 500 characters" }, 400);
+    try {
+      const meta = createCheckpoint(repoDir, message);
+      audit(db, { kind: "checkpoint.create", target: String(meta.id), result: "ok" });
+      return c.json(meta, 201);
+    } catch (e) {
+      audit(db, { kind: "checkpoint.create", result: "error", detail: (e as Error).message });
+      return c.json({ error: "could not create the checkpoint" }, 500);
+    }
+  });
+  act.post("/v1/checkpoints/:id/rollback", (c) => {
+    if (!ctx.local(c)) return c.json({ error: "loopback JSON requests only" }, 403);
+    const id = c.req.param("id");
+    if (!validCheckpointId(id)) { audit(db, { kind: "checkpoint.rollback", target: id.slice(0, 128), result: "refused", detail: "invalid id" }); return c.json({ error: "invalid checkpoint id" }, 400); }
+    const r = rollbackCheckpoint(repoDir, id);
+    if (!r) { audit(db, { kind: "checkpoint.rollback", target: id, result: "refused", detail: "not found" }); return c.json({ error: "checkpoint not found" }, 404); }
+    audit(db, { kind: "checkpoint.rollback", target: id, result: r.errors.length ? "partial" : "ok", detail: `restored ${r.restored}; pre-rollback snapshot ${r.pre_rollback_snapshot}` });
+    return c.json({ ...r, message: `Restored ${r.restored} item(s) from ${id}. Prior state saved as ${r.pre_rollback_snapshot} (undo this rollback by restoring it).` });
+  });
+}

package/packages/control-plane/src/server/routes/index.ts

@@ -7,12 +7,15 @@ import { isLoopbackHost } from "../auth.ts";
 import { mountRepos } from "../repos.ts";
 import { mount as artifacts } from "./artifacts.ts";
 import { mount as audit } from "./audit.ts";
+import { mount as checkpoints } from "./checkpoints.ts";
 import { mount as config } from "./config.ts";
 import { mount as control } from "./control.ts";
 import { mount as cost } from "./cost.ts";
 import { mount as costLedger } from "./cost_ledger.ts";
 import { mount as fleet } from "./fleet.ts";
+import { mount as memory } from "./memory.ts";
 import { mount as metrics } from "./metrics.ts";
+import { mount as sessionControl } from "./session_control.ts";
 import { mount as integrations } from "./integrations.ts";
 import { mount as mergeRisk } from "./merge_risk.ts";
 import { mount as notify } from "./notify.ts";
@@ -40,7 +43,7 @@ export interface RouteCtx {
   answerDir?: string;
 }
 
-export const routeModules: ReadonlyArray<(ctx: RouteCtx) => void> = [artifacts, stream, start, control, stats, cost, costLedger, fleet, metrics, config, providers, verify, integrations, notify, audit, mergeRisk];
+export const routeModules: ReadonlyArray<(ctx: RouteCtx) => void> = [artifacts, stream, start, control, stats, cost, costLedger, fleet, metrics, checkpoints, memory, sessionControl, config, providers, verify, integrations, notify, audit, mergeRisk];
 
 export function registerRoutes(ctx: RouteCtx): void {
   mountRepos(ctx.act, ctx.db, ctx.peerIsLoopback);