@desplega.ai/agent-swarm 1.91.0 → 1.92.1

package/src/heartbeat/templates.ts

@@ -27,17 +27,19 @@ Goal: Review system status and your standing orders, take action if needed.
 
 ## Instructions
 1. **Read your HEARTBEAT.md** — run \`read /workspace/HEARTBEAT.md\` to get the latest standing orders (the snapshot above may be slightly stale).
-2. Review the system status above for anything that needs attention (stalled tasks, idle workers with available work, anomalies).
-3. **CRITICAL — Reboot failure triage:** Failures with reason "worker session not found" or "worker session heartbeat is stale" indicate tasks that were INTERRUPTED by a server restart. These are NOT "expected auto-cleanup" — they represent work that was lost mid-execution. For each such failure:
+2. **Prune tracked HEARTBEAT items FIRST.** Active Blockers + Watch Items + Open Discussion combined must stay at ≤10 items; 20 is the absolute max only when genuinely super busy. This cap does not apply to evergreen Standing Orders / Governance / Playbook-index reference sections. Before adding anything, re-check every tracked item against its lift trigger and remove anything resolved, stale, or past its trigger date. Lift incident detail to memory; never keep it inline in HEARTBEAT.md. Every new tracked item must include an explicit lift trigger + date; if it has no removal condition, do not add it. If the tracked list is already at/over cap, prune before (or instead of) adding — the cap is binding.
+3. **Run seeded heartbeat data-gathering.** Use \`script-run\` with global script \`Heartbeat Audit\` and pass the current HEARTBEAT.md text as \`heartbeatMarkdown\`. It covers Rules #10/#13/#15/#16/#17: resolved stale PRs, pool-target risk schedules, schedule/provider failure clusters, and whether daily-blocker-digest ran today. The Slack thread-reply check (Rule #11) stays Lead-side; the script runtime has no Slack token.
+4. Review the system status above plus the \`Heartbeat Audit\` result for anything that needs attention (stalled tasks, idle workers with available work, anomalies).
+5. **CRITICAL — Reboot failure triage:** Failures with reason "worker session not found" or "worker session heartbeat is stale" indicate tasks that were INTERRUPTED by a server restart. These are NOT "expected auto-cleanup" — they represent work that was lost mid-execution. For each such failure:
    - Check what the task was (via \`get-task-details\` with the task ID from the failure)
    - If a retry task was auto-created (tagged \`reboot-retry\`), verify it is progressing
    - If no retry exists and the work is still needed, re-create the task
    - Do NOT dismiss these as "expected" or "auto-cleanup"
-4. Review your standing orders for any periodic checks or actions.
-5. If something needs attention — take action now using your available tools (create tasks, post to Slack, cancel stuck tasks, etc.).
-6. If everything looks healthy and no standing orders are actionable — complete this task with a brief "All clear" summary. You may NOT say "All clear" if reboot-related failures exist that haven't been triaged.
-7. Do NOT create another heartbeat-checklist task — the system handles scheduling.
-8. **Update your standing orders** — After every heartbeat check, edit \`/workspace/HEARTBEAT.md\` directly. Add new patterns you noticed (recurring failures, workers needing attention), remove resolved items. This is your live operational runbook — keep it current.`,
+6. Review your standing orders for any periodic checks or actions.
+7. If something needs attention — take action now using your available tools (create tasks, post to Slack, cancel stuck tasks, etc.).
+8. If everything looks healthy and no standing orders are actionable — complete this task with a brief "All clear" summary. You may NOT say "All clear" if reboot-related failures exist that haven't been triaged.
+9. Do NOT create another heartbeat-checklist task — the system handles scheduling.
+10. **Update HEARTBEAT.md only after pruning.** Keep it current, but keep tracked items capped: remove resolved items, add only dated lift-triggered items, and lift detail to memory instead of growing the file.`,
   variables: [
     {
       name: "system_status",
@@ -73,22 +75,24 @@ The API server has just restarted (deployment, pod rotation, or crash). An aggre
 {{heartbeat_content}}
 
 ## Instructions
-1. **Triage reboot-interrupted work FIRST.** If the "Reboot-Interrupted Work" section above lists tasks:
+1. **Prune tracked HEARTBEAT items FIRST.** Active Blockers + Watch Items + Open Discussion combined must stay at ≤10 items; 20 is the absolute max only when genuinely super busy. This cap does not apply to evergreen Standing Orders / Governance / Playbook-index reference sections. Before adding anything, re-check every tracked item against its lift trigger and remove anything resolved, stale, or past its trigger date. Lift incident detail to memory; never keep it inline in HEARTBEAT.md. Every new tracked item must include an explicit lift trigger + date; if it has no removal condition, do not add it. If the tracked list is already at/over cap, prune before (or instead of) adding — the cap is binding.
+2. **Run seeded boot triage.** Use \`script-run\` with global script \`boot-triage\` to gather deploy-restart PR context, recent real failures, stuck offline-agent work, orphaned pending/offered tasks, and superseded tasks missing resume children in one read-only call.
+3. **Triage reboot-interrupted work FIRST.** If the "Reboot-Interrupted Work" section above or the \`boot-triage\` result lists tasks:
    - For each task: verify the retry is progressing via \`get-task-details\` with the retry task ID
    - If a retry failed or is stuck, re-create the task manually
    - If the work is no longer needed, cancel the retry task
    - You MUST address every item — do NOT skip this section
-2. **Verify supersede + resume worked end-to-end.** Worker crashes / OOMs are recovered via supersede (parent → \`superseded\`) + a fresh \`taskType=resume\` child created by the heartbeat sweep (DES-523). Sanity check:
+4. **Verify supersede + resume worked end-to-end.** Worker crashes / OOMs are recovered via supersede (parent → \`superseded\`) + a fresh \`taskType=resume\` child created by the heartbeat sweep (DES-523). Sanity check:
    - List recent \`superseded\` tasks: \`list-tasks status=superseded\` (last ~hour).
    - For each, confirm a child task with \`taskType=resume\` and a non-terminal status exists. If a superseded task is missing its resume child, the work is silently dropped — recreate the task manually.
    - Look for \`in_progress\` tasks older than 5 min on agents that show as offline — the sweep should have caught them. If any remain, recreate as needed.
-3. **Check orphaned tasks.** If the "Orphaned Tasks" section lists pending/offered tasks assigned to offline workers, re-assign or cancel them.
-4. Review agent status — are all expected workers online? If not, note which are missing.
-5. Review your standing orders for any post-reboot checks.
-6. Take action using your available tools.
-7. Complete this task with a summary of what you found and what actions you took. Include the status of each reboot-interrupted task.
-8. Do NOT create another boot-triage task — this is a one-off event.
-9. **Update your standing orders** — If the reboot revealed a pattern worth monitoring (e.g., frequent restarts, specific tasks that keep failing), add a standing order to HEARTBEAT.md via \`update-profile\` with \`heartbeatMd\`.`,
+5. **Check orphaned tasks.** If the "Orphaned Tasks" section or \`boot-triage\` result lists pending/offered tasks assigned to offline workers, re-assign or cancel them.
+6. Review agent status — are all expected workers online? If not, note which are missing.
+7. Review your standing orders for any post-reboot checks.
+8. Take action using your available tools.
+9. Complete this task with a summary of what you found and what actions you took. Include the status of each reboot-interrupted task.
+10. Do NOT create another boot-triage task — this is a one-off event.
+11. **Update HEARTBEAT.md only after pruning.** If the reboot revealed a pattern worth monitoring, add it only as a dated lift-triggered tracked item and only if the cap still holds after pruning. Lift incident detail to memory instead of growing HEARTBEAT.md.`,
   variables: [
     {
       name: "system_status",

package/src/http/db-query.ts

@@ -11,6 +11,24 @@ export interface DbQueryResult {
   total: number;
 }
 
+export const DbQueryInputShape = {
+  sql: z.string().min(1).max(10_000).optional(),
+  query: z.string().min(1).max(10_000).optional().describe("Deprecated runtime alias for sql."),
+  params: z.array(z.any()).optional().default([]),
+};
+
+export const DbQueryInputSchema = z
+  .object(DbQueryInputShape)
+  .refine((body) => body.sql !== undefined || body.query !== undefined, {
+    message: "Either sql or query is required",
+  });
+
+export type DbQueryInput = z.infer<typeof DbQueryInputSchema>;
+
+export function resolveDbQuerySql(input: Pick<DbQueryInput, "sql" | "query">): string {
+  return input.sql ?? input.query ?? "";
+}
+
 function stripTrailingSemicolon(sql: string): string {
   return sql.trim().replace(/;\s*$/, "").trim();
 }
@@ -67,10 +85,7 @@ const dbQueryRoute = route({
   pattern: ["api", "db-query"],
   summary: "Execute a read-only SQL query",
   tags: ["Debug"],
-  body: z.object({
-    sql: z.string().min(1).max(10_000),
-    params: z.array(z.any()).optional().default([]),
-  }),
+  body: DbQueryInputSchema,
   responses: {
     200: {
       description: "Query results",
@@ -100,7 +115,7 @@ export async function handleDbQuery(
   if (!parsed) return true;
 
   try {
-    const result = executeReadOnlyQuery(parsed.body.sql, parsed.body.params);
+    const result = executeReadOnlyQuery(resolveDbQuerySql(parsed.body), parsed.body.params);
     json(res, result);
   } catch (err: unknown) {
     const message = err instanceof Error ? err.message : String(err);

package/src/http/index.ts

@@ -21,9 +21,11 @@ import {
   withRemoteContext,
   withSpanContext,
 } from "../otel";
+import { startScriptRunSupervisor, stopScriptRunSupervisor } from "../script-workflows/supervisor";
 import { startSlackApp, stopSlackApp } from "../slack";
 import { initTelemetry, telemetry } from "../telemetry";
 import { getApiKey } from "../utils/api-key";
+import { getMcpBaseUrl } from "../utils/constants";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { initWorkflows } from "../workflows";
 import { handleActiveSessions } from "./active-sessions";
@@ -41,12 +43,17 @@ import { handleHeartbeat } from "./heartbeat";
 import { handleInboxState } from "./inbox-state";
 import { handleIntegrations } from "./integrations";
 import { handleKv } from "./kv";
-import { handleMcp } from "./mcp";
+import {
+  closeIdleMcpTransports,
+  DEFAULT_MCP_TRANSPORT_IDLE_TIMEOUT_MS,
+  handleMcp,
+  type McpTransportActivity,
+} from "./mcp";
 import { handleMcpBridge } from "./mcp-bridge";
 import { handleMcpOAuth, startMcpOAuthPendingGc, stopMcpOAuthPendingGc } from "./mcp-oauth";
 import { handleMcpServers } from "./mcp-servers";
-import { handleMcpUser } from "./mcp-user";
-import { handleMemory } from "./memory";
+import { closeIdleMcpUserTransports, handleMcpUser } from "./mcp-user";
+import { handleMemory, startMemoryGc, stopMemoryGc } from "./memory";
 import { handleMetrics } from "./metrics";
 import { handlePageProxy } from "./page-proxy";
 import { handlePages } from "./pages";
@@ -57,6 +64,7 @@ import { handlePromptTemplates } from "./prompt-templates";
 import { handleRepos } from "./repos";
 import { describeRequestRoute } from "./route-def";
 import { handleSchedules } from "./schedules";
+import { handleScriptRuns } from "./script-runs";
 import { handleScripts } from "./scripts";
 import { handleSessionData } from "./session-data";
 import { handleSessions } from "./sessions";
@@ -96,12 +104,15 @@ const globalState = globalThis as typeof globalThis & {
   __transports?: Record<string, StreamableHTTPServerTransport>;
   __transportsUser?: Record<string, StreamableHTTPServerTransport>;
   __sessionUsers?: Record<string, string>;
+  __transportActivity?: McpTransportActivity;
+  __transportActivityUser?: McpTransportActivity;
   __sigintRegistered?: boolean;
   __apiGcInterval?: ReturnType<typeof setInterval>;
   __runId?: string;
 };
 
 const API_GC_INTERVAL_MS = 5 * 60 * 1000;
+const MCP_TRANSPORT_IDLE_TIMEOUT_MS = DEFAULT_MCP_TRANSPORT_IDLE_TIMEOUT_MS;
 
 type GcCapableGlobal = typeof globalThis & { gc?: () => void };
 
@@ -127,11 +138,25 @@ function startApiGcInterval() {
 
   const gc = (globalThis as GcCapableGlobal).gc;
   if (typeof gc !== "function") {
-    console.log("[HTTP] Explicit GC unavailable; start API with --expose-gc to enable sweeps");
-    return;
+    console.log("[HTTP] Explicit GC unavailable; idle MCP transport sweeps remain enabled");
   }
 
   const interval = setInterval(() => {
+    const closedOwnerTransports = closeIdleMcpTransports(transports, transportActivity, {
+      idleTimeoutMs: MCP_TRANSPORT_IDLE_TIMEOUT_MS,
+      label: "MCP",
+    });
+    const closedUserTransports = closeIdleMcpUserTransports(
+      transportsUser,
+      sessionUsers,
+      transportActivityUser,
+      { idleTimeoutMs: MCP_TRANSPORT_IDLE_TIMEOUT_MS },
+    );
+    if (closedOwnerTransports > 0 || closedUserTransports > 0) {
+      console.log(
+        `[HTTP] Closed ${closedOwnerTransports} owner MCP and ${closedUserTransports} user MCP idle transport(s)`,
+      );
+    }
     scheduleApiGc("periodic API sweep");
   }, API_GC_INTERVAL_MS);
   interval.unref?.();
@@ -148,6 +173,8 @@ const transports: Record<string, StreamableHTTPServerTransport> = globalState.__
 const transportsUser: Record<string, StreamableHTTPServerTransport> =
   globalState.__transportsUser ?? {};
 const sessionUsers: Record<string, string> = globalState.__sessionUsers ?? {};
+const transportActivity: McpTransportActivity = globalState.__transportActivity ?? {};
+const transportActivityUser: McpTransportActivity = globalState.__transportActivityUser ?? {};
 
 const httpServer = createHttpServer(async (req, res) => {
   const startTime = performance.now();
@@ -272,6 +299,7 @@ const httpServer = createHttpServer(async (req, res) => {
         () => handleMetrics(req, res, pathSegments, queryParams, myAgentId),
         () => handleRepos(req, res, pathSegments, queryParams),
         () => handleSkills(req, res, pathSegments, queryParams, myAgentId),
+        () => handleScriptRuns(req, res, pathSegments, queryParams, myAgentId),
         () => handleScripts(req, res, pathSegments, queryParams, myAgentId),
         () => handleMcpBridge(req, res, pathSegments, queryParams, myAgentId),
         () => handleMcpServers(req, res, pathSegments, queryParams),
@@ -287,8 +315,8 @@ const httpServer = createHttpServer(async (req, res) => {
         () => handleSessions(req, res, pathSegments, queryParams),
         () => handleInboxState(req, res, pathSegments, queryParams),
         () => handleTaskTemplates(req, res, pathSegments, queryParams),
-        () => handleMcp(req, res, transports),
-        () => handleMcpUser(req, res, transportsUser, sessionUsers),
+        () => handleMcp(req, res, transports, transportActivity),
+        () => handleMcpUser(req, res, transportsUser, sessionUsers, transportActivityUser),
       ];
 
       try {
@@ -330,6 +358,8 @@ globalState.__httpServer = httpServer;
 globalState.__transports = transports;
 globalState.__transportsUser = transportsUser;
 globalState.__sessionUsers = sessionUsers;
+globalState.__transportActivity = transportActivity;
+globalState.__transportActivityUser = transportActivityUser;
 
 async function shutdown() {
   console.log("Shutting down HTTP server...");
@@ -343,6 +373,9 @@ async function shutdown() {
   // Stop heartbeat triage
   stopHeartbeat();
 
+  // Stop durable script workflow subprocesses
+  stopScriptRunSupervisor();
+
   // Stop Slack bot
   await stopSlackApp();
 
@@ -355,6 +388,9 @@ async function shutdown() {
   // Stop MCP OAuth pending-session garbage collector
   stopMcpOAuthPendingGc();
 
+  // Stop memory expired-row garbage collector
+  stopMemoryGc();
+
   if (globalState.__apiGcInterval) {
     clearInterval(globalState.__apiGcInterval);
     delete globalState.__apiGcInterval;
@@ -365,6 +401,7 @@ async function shutdown() {
     console.log(`[HTTP] Closing transport ${id}`);
     transport.close();
     delete transports[id];
+    delete transportActivity[id];
   }
 
   for (const [id, transport] of Object.entries(transportsUser)) {
@@ -372,6 +409,7 @@ async function shutdown() {
     transport.close();
     delete transportsUser[id];
     delete sessionUsers[id];
+    delete transportActivityUser[id];
   }
 
   // Close all active connections forcefully
@@ -487,6 +525,9 @@ httpServer
     // Initialize workflow engine (trigger subscriptions + resume listener)
     initWorkflows();
 
+    // Reconcile durable script workflow subprocesses
+    startScriptRunSupervisor(getMcpBaseUrl());
+
     // Start scheduler (if enabled)
     if (hasCapability("scheduling")) {
       const { startScheduler } = await import("../scheduler");
@@ -512,6 +553,9 @@ httpServer
 
     // Start MCP OAuth pending-session garbage collector (5-min tick)
     startMcpOAuthPendingGc();
+
+    // Start expired-memory garbage collector (1-hour tick, immediate first run)
+    startMemoryGc();
   })
   .on("error", (err) => {
     console.error("HTTP Server Error:", err);

package/src/http/mcp-user.ts

@@ -5,6 +5,7 @@ import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import { resolveUserByToken } from "@/be/users";
 import { createUserServer } from "@/server-user";
 import type { User } from "@/types";
+import { closeIdleMcpTransports, type McpTransportActivity, markMcpTransportActivity } from "./mcp";
 
 function unauthorized(res: ServerResponse): true {
   res.writeHead(401, { "Content-Type": "application/json" });
@@ -32,6 +33,7 @@ export async function handleMcpUser(
   res: ServerResponse,
   transports: Record<string, StreamableHTTPServerTransport>,
   sessionUsers: Record<string, string>,
+  sessionActivity: McpTransportActivity = {},
 ): Promise<boolean> {
   const sessionId = req.headers["mcp-session-id"] as string | undefined;
 
@@ -57,16 +59,19 @@ export async function handleMcpUser(
 
     if (sessionId && transports[sessionId]) {
       transport = transports[sessionId];
+      markMcpTransportActivity(sessionActivity, sessionId);
     } else if (!sessionId && isInitializeRequest(body)) {
       transport = new StreamableHTTPServerTransport({
         sessionIdGenerator: () => randomUUID(),
         onsessioninitialized: (id) => {
           transports[id] = transport;
           sessionUsers[id] = user.id;
+          markMcpTransportActivity(sessionActivity, id);
         },
         onsessionclosed: (id) => {
           delete transports[id];
           delete sessionUsers[id];
+          delete sessionActivity[id];
         },
       });
 
@@ -74,6 +79,7 @@ export async function handleMcpUser(
         if (transport.sessionId) {
           delete transports[transport.sessionId];
           delete sessionUsers[transport.sessionId];
+          delete sessionActivity[transport.sessionId];
         }
       };
 
@@ -92,11 +98,13 @@ export async function handleMcpUser(
     }
 
     await transport.handleRequest(req, res, body);
+    markMcpTransportActivity(sessionActivity, transport.sessionId);
     return true;
   }
 
   if (req.method === "GET" || req.method === "DELETE") {
     if (sessionId && transports[sessionId]) {
+      markMcpTransportActivity(sessionActivity, sessionId);
       await transports[sessionId].handleRequest(req, res);
       return true;
     }
@@ -109,3 +117,18 @@ export async function handleMcpUser(
   res.end("Method not allowed");
   return true;
 }
+
+export function closeIdleMcpUserTransports(
+  transports: Record<string, StreamableHTTPServerTransport>,
+  sessionUsers: Record<string, string>,
+  sessionActivity: McpTransportActivity,
+  options: { now?: number; idleTimeoutMs?: number } = {},
+): number {
+  return closeIdleMcpTransports(transports, sessionActivity, {
+    ...options,
+    label: "user MCP",
+    onClose: (id) => {
+      delete sessionUsers[id];
+    },
+  });
+}

package/src/http/mcp.ts

@@ -4,10 +4,62 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import { createServer } from "@/server";
 
+export type McpTransportActivity = Record<string, number>;
+
+export const DEFAULT_MCP_TRANSPORT_IDLE_TIMEOUT_MS = 2 * 60 * 60 * 1000;
+
+export function markMcpTransportActivity(
+  sessionActivity: McpTransportActivity,
+  sessionId: string | undefined,
+  now = Date.now(),
+): void {
+  if (sessionId) {
+    sessionActivity[sessionId] = now;
+  }
+}
+
+export function closeIdleMcpTransports(
+  transports: Record<string, StreamableHTTPServerTransport>,
+  sessionActivity: McpTransportActivity,
+  options: {
+    now?: number;
+    idleTimeoutMs?: number;
+    label?: string;
+    onClose?: (id: string) => void;
+  } = {},
+): number {
+  const now = options.now ?? Date.now();
+  const idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_MCP_TRANSPORT_IDLE_TIMEOUT_MS;
+  let closed = 0;
+
+  for (const [id, transport] of Object.entries(transports)) {
+    const lastActivity = sessionActivity[id];
+    if (lastActivity === undefined) {
+      sessionActivity[id] = now;
+      continue;
+    }
+    if (now - lastActivity < idleTimeoutMs) continue;
+
+    try {
+      transport.close();
+    } catch (err) {
+      console.warn(`[HTTP] Failed to close idle ${options.label ?? "MCP"} transport ${id}: ${err}`);
+    } finally {
+      delete transports[id];
+      delete sessionActivity[id];
+      options.onClose?.(id);
+      closed++;
+    }
+  }
+
+  return closed;
+}
+
 export async function handleMcp(
   req: IncomingMessage,
   res: ServerResponse,
   transports: Record<string, StreamableHTTPServerTransport>,
+  sessionActivity: McpTransportActivity = {},
 ): Promise<boolean> {
   const sessionId = req.headers["mcp-session-id"] as string | undefined;
 
@@ -26,20 +78,24 @@ export async function handleMcp(
 
     if (sessionId && transports[sessionId]) {
       transport = transports[sessionId];
+      markMcpTransportActivity(sessionActivity, sessionId);
     } else if (!sessionId && isInitializeRequest(body)) {
       transport = new StreamableHTTPServerTransport({
         sessionIdGenerator: () => randomUUID(),
         onsessioninitialized: (id) => {
           transports[id] = transport;
+          markMcpTransportActivity(sessionActivity, id);
         },
         onsessionclosed: (id) => {
           delete transports[id];
+          delete sessionActivity[id];
         },
       });
 
       transport.onclose = () => {
         if (transport.sessionId) {
           delete transports[transport.sessionId];
+          delete sessionActivity[transport.sessionId];
         }
       };
 
@@ -58,11 +114,13 @@ export async function handleMcp(
     }
 
     await transport.handleRequest(req, res, body);
+    markMcpTransportActivity(sessionActivity, transport.sessionId);
     return true;
   }
 
   if (req.method === "GET" || req.method === "DELETE") {
     if (sessionId && transports[sessionId]) {
+      markMcpTransportActivity(sessionActivity, sessionId);
       await transports[sessionId].handleRequest(req, res);
       return true;
     }

package/src/http/memory.ts

@@ -115,6 +115,18 @@ const listMemory = route({
   },
 });
 
+const memoryHealth = route({
+  method: "get",
+  path: "/api/memory/health",
+  pattern: ["api", "memory", "health"],
+  summary: "Report memory vector index health and retrieval mode",
+  tags: ["Memory"],
+  auth: { apiKey: true },
+  responses: {
+    200: { description: "Memory vector index health" },
+  },
+});
+
 const deleteMemoryById = route({
   method: "delete",
   path: "/api/memory/{id}",
@@ -498,6 +510,14 @@ export async function handleMemory(
     return true;
   }
 
+  if (memoryHealth.match(req.method, pathSegments)) {
+    const parsed = await memoryHealth.parse(req, res, pathSegments, new URLSearchParams());
+    if (!parsed) return true;
+
+    json(res, getMemoryStore().getHealth());
+    return true;
+  }
+
   if (deleteMemoryById.match(req.method, pathSegments)) {
     const parsed = await deleteMemoryById.parse(req, res, pathSegments, new URLSearchParams());
     if (!parsed) return true;
@@ -663,3 +683,41 @@ export async function handleMemory(
 
   return false;
 }
+
+// ─── Expired Memory GC ──────────────────────────────────────────────────────
+
+const MEMORY_GC_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+let memoryGcTimer: ReturnType<typeof setInterval> | null = null;
+
+export function startMemoryGc(intervalMs = MEMORY_GC_INTERVAL_MS): void {
+  if (memoryGcTimer) return;
+
+  // Run immediately on startup to clear any backlog
+  try {
+    const purged = getMemoryStore().purgeExpired();
+    if (purged > 0) {
+      console.log(`[memory-gc] Initial purge removed ${purged} expired memory row(s)`);
+    }
+  } catch (err) {
+    console.error("[memory-gc] Initial purge failed:", err);
+  }
+
+  memoryGcTimer = setInterval(() => {
+    try {
+      const purged = getMemoryStore().purgeExpired();
+      if (purged > 0) {
+        console.log(`[memory-gc] Periodic purge removed ${purged} expired memory row(s)`);
+      }
+    } catch (err) {
+      console.error("[memory-gc] Periodic purge failed:", err);
+    }
+  }, intervalMs);
+  if (typeof memoryGcTimer?.unref === "function") memoryGcTimer.unref();
+}
+
+export function stopMemoryGc(): void {
+  if (memoryGcTimer) {
+    clearInterval(memoryGcTimer);
+    memoryGcTimer = null;
+  }
+}

package/src/http/pages.ts

@@ -58,7 +58,7 @@ const createPageRoute = route({
     title: z.string().min(1),
     description: z.string().optional(),
     contentType: PageContentTypeSchema,
-    authMode: PageAuthModeSchema,
+    authMode: PageAuthModeSchema.default("authed"),
     password: z.string().min(1).optional(),
     body: z.string(),
     needsCredentials: z.array(z.string()).optional(),