@akira-tl/forgerelay 0.3.5 → 0.3.7

package/dist/server.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { access, realpath } from "node:fs/promises";
 import { tmpdir } from "node:os";
+import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
@@ -42,6 +43,7 @@ import { formatLocalAgentProviderAvailabilitySummary, getLocalAgentProviderAvail
 // transport. Bound stale transport-session retention so abandoned transports do
 // not accumulate for the life of the process.
 const MCP_TRANSPORT_IDLE_TIMEOUT_MS = 24 * 60 * 60 * 1_000;
+const MAX_MCP_TRANSPORT_SESSIONS = 64;
 const FORGERELAY_VERSION = readForgeRelayVersion();
 const MCP_TRANSPORT_CLEANUP_INTERVAL_MS = 5 * 60 * 1_000;
 const WRITE_TOOL_ANNOTATIONS = {
@@ -92,6 +94,30 @@ function workspaceLogContext(workspace, _transportSessionId) {
         workspace: workspaceLogLabel(workspace.root, workspace.id),
     };
 }
+function formatDiscoveredWorkspaceInstructions(files, workspaceRoot) {
+    return [
+        "Workspace instructions discovered for this path. Apply them to follow-up work under their directories:",
+        ...files.flatMap((file) => [
+            `--- ${formatAgentsPath(file.path, workspaceRoot)} ---`,
+            file.content.trimEnd(),
+        ]),
+    ].join("\n");
+}
+async function assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, paths) {
+    const discovered = new Map();
+    for (const path of paths) {
+        const absolutePath = resolve(workspace.root, path);
+        for (const file of await workspaces.discoverPathInstructions(workspace, absolutePath)) {
+            discovered.set(file.path, file);
+        }
+    }
+    if (discovered.size === 0)
+        return;
+    throw new Error([
+        formatDiscoveredWorkspaceInstructions([...discovered.values()], workspace.root),
+        "Apply these instructions, then retry this tool call. No mutation or command was executed.",
+    ].join("\n"));
+}
 function formatVisibleAgent(agent) {
     const model = agent.model ? `, model ${agent.model}` : "";
     const thinking = agent.thinking ? `, thinking ${agent.thinking}` : "";
@@ -164,6 +190,36 @@ const workspaceLocalAgentProviderOutputSchema = z.object({
 const workspaceAvailableAgentsFileOutputSchema = z.object({
     path: z.string(),
 });
+const workspaceInventoryEntryOutputSchema = z.object({
+    label: z.string(),
+    workspaceId: z.string(),
+    root: z.string(),
+    status: z.string(),
+    state: z.enum(["active", "stale", "invalid", "closed"]),
+    mode: z.enum(["checkout", "worktree"]),
+    sourceRoot: z.string().optional(),
+    branch: z.string().optional(),
+    targetBranch: z.string().optional(),
+    managed: z.boolean(),
+    createdAt: z.string(),
+    lastUsedAt: z.string(),
+    idleMs: z.number().nonnegative(),
+    rootValid: z.boolean(),
+    current: z.boolean(),
+});
+const workspaceInventorySummaryOutputSchema = z.object({
+    total: z.number().int().nonnegative(),
+    matching: z.number().int().nonnegative(),
+    active: z.number().int().nonnegative(),
+    stale: z.number().int().nonnegative(),
+    invalid: z.number().int().nonnegative(),
+    closed: z.number().int().nonnegative(),
+});
+const workspaceInventoryPageOutputSchema = z.object({
+    offset: z.number().int().nonnegative(),
+    limit: z.number().int().positive(),
+    hasMore: z.boolean(),
+});
 const reviewFileOutputSchema = z.object({
     path: z.string(),
     previousPath: z.string().optional(),
@@ -578,6 +634,7 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
                 operation: async () => {
                     const startedAt = performance.now();
                     const cwd = workspaces.resolveWorkingDirectory(workspace, workingDirectory);
+                    await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [cwd]);
                     const snapshot = await processSessions.start({
                         workspaceId,
                         command: cmd,
@@ -775,20 +832,24 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     }, async (uri, _variables, extra) => readWorkspaceAppResource(config, uri.toString(), extra.sessionId));
     registerAppTool(server, "open_workspace", {
         title: "Open workspace",
-        description: "Open or resume a local coding workspace. Reuse the returned workspaceId for later calls. Default to checkout; use mode=\"worktree\" only when the user explicitly requests isolated or parallel Git work. Every call returns a capability fingerprint; bootstrap calls also expose project context, skills, and capability guides when needed.",
+        description: "Open or resume a local coding workspace. Reuse the returned workspaceId for later calls. Default to checkout; use mode=\"worktree\" only when the user explicitly requests isolated or parallel Git work. Every call returns lightweight workspace metadata; bootstrap context is delivered automatically only when needed and can be explicitly suppressed or refreshed.",
         inputSchema: {
+            action: z
+                .enum(["open", "list"])
+                .optional()
+                .describe("Defaults to open. Use list only when you need to inspect or choose logical workspaces before resuming or cleaning them up."),
             path: z
                 .string()
                 .optional()
-                .describe("Project path to open. Required unless workspaceId is supplied. With mode=\"worktree\", this may also be a managed worktree path previously returned by ForgeRelay."),
+                .describe("Project path to open. Required for action=open unless workspaceId is supplied. With mode=\"worktree\", this may also be a managed worktree path previously returned by ForgeRelay."),
             workspaceId: z
                 .string()
                 .optional()
-                .describe("Existing logical workspace ID to resume in this conversation. When supplied, ForgeRelay resumes that workspace rather than allocating another ID."),
+                .describe("For action=open, an existing logical workspace ID to resume in this conversation. For action=list, filters inventory to one workspace ID."),
             mode: z
                 .enum(["checkout", "worktree"])
                 .optional()
-                .describe("Defaults to checkout, which works in the actual directory. Use worktree only when the user explicitly requests isolated or parallel Git work."),
+                .describe("For action=open, defaults to checkout and uses the actual directory unless worktree isolation is explicitly requested. For action=list, filters by workspace mode."),
             baseRef: z
                 .string()
                 .optional()
@@ -801,11 +862,45 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 .boolean()
                 .optional()
                 .describe("When true, allocate a fresh logical workspaceId for the same physical checkout or worktree and bind this conversation to it. Use only after the user explicitly requests a new logical workspace."),
+            context: z
+                .enum(["auto", "full", "none"])
+                .optional()
+                .describe("Bootstrap context policy for action=open. auto (default) sends full project context only when this conversation has not received the current context fingerprint; full forces a refresh; none opens/resumes without returning the full bootstrap context."),
+            root: z
+                .string()
+                .optional()
+                .describe("For action=list, filter by canonical workspace root or source root."),
+            status: z
+                .string()
+                .optional()
+                .describe("For action=list, filter by persisted workspace status such as active or closed."),
+            state: z
+                .enum(["active", "stale", "invalid", "closed"])
+                .optional()
+                .describe("For action=list, filter by derived lifecycle state."),
+            staleOnly: z
+                .boolean()
+                .optional()
+                .describe("For action=list, return only active logical workspaces idle for more than two days."),
+            offset: z
+                .number()
+                .int()
+                .nonnegative()
+                .optional()
+                .describe("For action=list, zero-based inventory offset. Defaults to 0."),
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(100)
+                .optional()
+                .describe("For action=list, maximum records to return. Defaults to 50; maximum 100."),
         },
         outputSchema: {
-            workspaceId: z.string(),
-            root: z.string(),
-            mode: z.enum(["checkout", "worktree"]),
+            action: z.enum(["open", "list"]),
+            workspaceId: z.string().optional(),
+            root: z.string().optional(),
+            mode: z.enum(["checkout", "worktree"]).optional(),
             sourceRoot: z.string().optional(),
             worktree: z
                 .object({
@@ -828,7 +923,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 targetBranch: z.string().optional(),
                 managed: z.boolean(),
                 current: z.boolean(),
-            })),
+            })).optional(),
             staleWorkspaces: z.array(z.object({
                 workspaceId: z.string(),
                 root: z.string(),
@@ -838,9 +933,10 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 branch: z.string().optional(),
                 targetBranch: z.string().optional(),
                 managed: z.boolean(),
-            })),
-            capabilityFingerprint: capabilityFingerprintOutputSchema,
-            capabilityCatalog: z.array(capabilityCatalogOutputSchema),
+            })).optional(),
+            capabilityFingerprint: capabilityFingerprintOutputSchema.optional(),
+            contextFingerprint: z.string().optional(),
+            capabilityCatalog: z.array(capabilityCatalogOutputSchema).optional(),
             capabilityGuides: z.array(capabilityGuideOutputSchema).optional(),
             agentsFiles: z.array(workspaceAgentsFileOutputSchema).optional(),
             availableAgentsFiles: z.array(workspaceAvailableAgentsFileOutputSchema).optional(),
@@ -848,6 +944,9 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             agentProviders: z.array(workspaceLocalAgentProviderOutputSchema).optional(),
             agents: z.array(workspaceLocalAgentOutputSchema).optional(),
             skillDiagnostics: z.array(z.unknown()).optional(),
+            workspaces: z.array(workspaceInventoryEntryOutputSchema).optional(),
+            summary: workspaceInventorySummaryOutputSchema.optional(),
+            page: workspaceInventoryPageOutputSchema.optional(),
             instruction: z.string(),
         },
         ...toolWidgetDescriptorMeta(config, "workspace"),
@@ -857,11 +956,62 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             idempotentHint: false,
             openWorldHint: false,
         },
-    }, async ({ path, workspaceId, mode, baseRef, newWorktree, newWorkspace }, { _meta, sessionId }) => {
+    }, async ({ action = "open", path, workspaceId, mode, baseRef, newWorktree, newWorkspace, context, root, status, state, staleOnly, offset, limit, }, { _meta, sessionId }) => {
         const startedAt = performance.now();
-        const { workspace, agentsFiles, availableAgentsFiles, hookReports, workspaceReused, includeBootstrapContext, } = await workspaces.openWorkspace({ path, workspaceId, mode, baseRef, newWorktree, newWorkspace }, {
-            conversationScopeId: openAiConversationScopeId(_meta),
-            protectedWorkspaceIds: processSessions.activeWorkspaceIds(),
+        const conversationScopeId = openAiConversationScopeId(_meta);
+        const protectedWorkspaceIds = processSessions.activeWorkspaceIds();
+        if (action === "list") {
+            if (path !== undefined || baseRef !== undefined || newWorktree !== undefined ||
+                newWorkspace !== undefined || context !== undefined) {
+                throw new Error("open_workspace action=list does not accept path, baseRef, newWorktree, newWorkspace, or context. Use root/workspaceId/mode/status/state/staleOnly for inventory filters.");
+            }
+            const inventory = await workspaces.listWorkspaces({ workspaceId, mode, root, status, state, staleOnly, offset, limit }, { conversationScopeId, protectedWorkspaceIds });
+            const nextOffset = inventory.page.offset + inventory.page.limit;
+            const instruction = [
+                "Resume a selected workspaceId with open_workspace(action=\"open\", workspaceId=...).",
+                "Use close_workspace only after the user chooses cleanup; never close inventory entries automatically.",
+                inventory.page.hasMore
+                    ? `More matching workspaces are available; continue with offset=${nextOffset}.`
+                    : undefined,
+            ].filter(Boolean).join(" ");
+            const result = [
+                `Logical workspace inventory: ${inventory.summary.matching} matching of ${inventory.summary.total} stored records.`,
+                `States: active=${inventory.summary.active}, stale=${inventory.summary.stale}, invalid=${inventory.summary.invalid}, closed=${inventory.summary.closed}.`,
+                ...inventory.workspaces.map((entry) => [
+                    entry.label,
+                    `state=${entry.state}`,
+                    `status=${entry.status}`,
+                    `mode=${entry.mode}`,
+                    entry.managed ? "managed" : undefined,
+                    entry.current ? "current" : undefined,
+                    `root=${entry.root}`,
+                    `last-used=${entry.lastUsedAt}`,
+                ].filter(Boolean).join(" ")),
+                instruction,
+            ].join("\n");
+            logToolCall(config, {
+                tool: "open_workspace",
+                action: "list",
+                path: root,
+                success: true,
+                durationMs: Math.round(performance.now() - startedAt),
+            });
+            return {
+                content: [textBlock(result)],
+                structuredContent: {
+                    action: "list",
+                    ...inventory,
+                    instruction,
+                },
+            };
+        }
+        if (root !== undefined || status !== undefined || state !== undefined ||
+            staleOnly !== undefined || offset !== undefined || limit !== undefined) {
+            throw new Error("open_workspace inventory filters root, status, state, staleOnly, offset, and limit are only valid with action=list.");
+        }
+        const { workspace, agentsFiles, availableAgentsFiles, hookReports, workspaceReused, includeBootstrapContext, contextFingerprint, } = await workspaces.openWorkspace({ path, workspaceId, mode, baseRef, newWorktree, newWorkspace, context }, {
+            conversationScopeId,
+            protectedWorkspaceIds,
         });
         const knownWorktrees = await workspaces.listKnownWorktrees(workspace);
         const staleWorkspaces = await workspaces.listStaleWorkspaces(workspace);
@@ -911,20 +1061,26 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
         const visibleAgents = includeBootstrapContext ? cardAgents : [];
         const loadedAgentsFiles = includeBootstrapContext ? cardAgentsFiles : [];
         const availableAgentsFileOutputs = includeBootstrapContext ? cardAvailableAgentsFiles : [];
+        const workspaceContextInstruction = "For later open_workspace calls, context=\"auto\" avoids repeating unchanged bootstrap context; use context=\"none\" when only the workspace handle/metadata is needed, or context=\"full\" to force a refresh.";
+        const workspaceManagementInstruction = "When you need to continue an earlier logical workspace or organize workspace state, use open_workspace(action=\"list\") to inspect candidates, then resume a selected workspaceId or ask the user before close_workspace cleanup.";
         const cardInstruction = config.skillsEnabled
-            ? "Use this workspaceId in all subsequent tool calls for this project. Follow loaded agentsFiles instructions. Read an availableAgentsFiles path before working under it. When a task matches an available skill or capability guide, read its advertised path before proceeding."
-            : "Use this workspaceId in all subsequent tool calls for this project. Follow loaded agentsFiles instructions. Read an availableAgentsFiles path before working under it. When a task matches a capability guide, read its advertised path before proceeding.";
+            ? `Use this workspaceId in all subsequent tool calls for this project. Follow loaded agentsFiles instructions. Read an availableAgentsFiles path before working under it. When a task matches an available skill or capability guide, read its advertised path before proceeding. ${workspaceContextInstruction} ${workspaceManagementInstruction}`
+            : `Use this workspaceId in all subsequent tool calls for this project. Follow loaded agentsFiles instructions. Read an availableAgentsFiles path before working under it. When a task matches a capability guide, read its advertised path before proceeding. ${workspaceContextInstruction} ${workspaceManagementInstruction}`;
         const instruction = workspaceReused
             ? includeBootstrapContext
                 ? [
                     `Workspace already exists as ${workspace.id} for this directory.`,
                     "Reuse this workspaceId for subsequent tool calls.",
                     "The complete project context is included because it has not yet been provided in this conversation or host context.",
+                    workspaceContextInstruction,
+                    workspaceManagementInstruction,
                 ].join("\n\n")
                 : [
                     `Workspace already open as ${workspace.id}.`,
                     "Reuse this workspaceId for subsequent tool calls. This is the same directory previously opened in this conversation.",
                     "Continue following the project instructions, nested instruction files, skills, capability guides, agent profiles, and diagnostics previously provided for this workspace. They remain active and are not repeated here.",
+                    workspaceContextInstruction,
+                    workspaceManagementInstruction,
                 ].join("\n\n")
             : workspace.mode === "worktree"
                 ? "Use this workspaceId for subsequent tool calls. Follow the project instructions, nested instruction files, skills, agent profiles, and diagnostics returned for this isolated worktree."
@@ -998,6 +1154,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     worktrees: knownWorktrees,
                     staleWorkspaces,
                     capabilityFingerprint,
+                    contextFingerprint,
                     capabilityCatalog,
                     agentsFiles: cardAgentsFiles,
                     availableAgentsFiles: cardAvailableAgentsFiles,
@@ -1017,6 +1174,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 },
             },
             structuredContent: {
+                action: "open",
                 workspaceId: workspace.id,
                 root: workspace.root,
                 mode: workspace.mode,
@@ -1025,6 +1183,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 worktrees: knownWorktrees,
                 staleWorkspaces,
                 capabilityFingerprint,
+                contextFingerprint,
                 capabilityCatalog,
                 ...(includeBootstrapContext
                     ? {
@@ -1205,14 +1364,15 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     if (!commitMessage) {
                         throw new Error(`Managed-worktree-backed workspace ${workspaceId} requires commitMessage when closing.`);
                     }
-                    const busyWorkspaceIds = workspaces
-                        .workspaceIdsForPhysicalWorkspace(workspace)
+                    const physicalWorkspaceIds = workspaces.workspaceIdsForPhysicalWorkspace(workspace);
+                    const busyWorkspaceIds = physicalWorkspaceIds
                         .filter((id) => processSessions.activeWorkspaceIds().has(id));
                     if (busyWorkspaceIds.length > 0) {
                         throw new Error(`Cannot close this worktree-backed workspace while logical workspace processes are still running or awaiting completion delivery: ${busyWorkspaceIds.join(", ")}.`);
                     }
                     const startedAt = performance.now();
                     const closed = await workspaces.closeWorktree(workspaceId, commitMessage);
+                    await Promise.all(physicalWorkspaceIds.map((id) => reviewCheckpoints.releaseWorkspace(id)));
                     const result = [
                         `Closed managed-worktree-backed workspace ${workspaceId}.`,
                         `Merged ${closed.branch} into ${closed.targetBranch} by fast-forward.`,
@@ -1252,6 +1412,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     throw new Error(`Workspace ${workspaceId} still owns a running process or an unconsumed process completion. Poll or consume it before closing this workspace.`);
                 }
                 workspaces.closeWorkspace(workspaceId);
+                await reviewCheckpoints.releaseWorkspace(workspaceId);
                 const result = `Closed checkout-backed workspace ${workspaceId}. Physical project files were not removed.`;
                 return {
                     content: [textBlock(result)],
@@ -1285,7 +1446,9 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 .optional()
                 .describe("Maximum number of lines to read."),
         },
-        outputSchema: resultOutputSchema(),
+        outputSchema: resultOutputSchema({
+            agentsFiles: z.array(workspaceAgentsFileOutputSchema).optional(),
+        }),
         ...toolWidgetDescriptorMeta(config, "read"),
         annotations: { readOnlyHint: true },
     }, async ({ workspaceId, ...input }, extra) => {
@@ -1298,6 +1461,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             operation: async () => {
                 const startedAt = performance.now();
                 const readPath = workspaces.resolveReadPath(workspace, input.path);
+                const discoveredInstructions = (await workspaces.discoverPathInstructions(workspace, readPath.absolutePath)).filter((file) => file.path !== readPath.absolutePath);
                 const response = await readFileTool({ ...input, path: readPath.absolutePath }, {
                     cwd: workspace.root,
                     root: workspace.root,
@@ -1312,6 +1476,12 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     return response;
                 }
                 workspaces.markReadPathLoaded(workspace, readPath);
+                const discoveredInstructionContent = discoveredInstructions.length > 0
+                    ? textBlock(formatDiscoveredWorkspaceInstructions(discoveredInstructions, workspace.root))
+                    : undefined;
+                const content = discoveredInstructionContent
+                    ? [discoveredInstructionContent, ...response.content]
+                    : response.content;
                 const summary = {
                     ...textSummary(response.content),
                     offset: input.offset ?? 1,
@@ -1326,6 +1496,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 });
                 return {
                     ...response,
+                    content,
                     _meta: {
                         tool: toolNames.read,
                         card: {
@@ -1336,7 +1507,15 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                         },
                     },
                     structuredContent: {
-                        result: contentText(response.content),
+                        result: contentText(content),
+                        ...(discoveredInstructions.length > 0
+                            ? {
+                                agentsFiles: discoveredInstructions.map((file) => ({
+                                    path: formatAgentsPath(file.path, workspace.root),
+                                    content: file.content,
+                                })),
+                            }
+                            : {}),
                     },
                 };
             },
@@ -1368,6 +1547,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 changedPaths: (result) => toolResultIsError(result) ? [] : [input.path],
                 operation: async () => {
                     const startedAt = performance.now();
+                    await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [input.path]);
                     const response = await writeFileTool(input, {
                         cwd: workspace.root,
                         root: workspace.root,
@@ -1450,6 +1630,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 changedPaths: (result) => toolResultIsError(result) ? [] : [input.path],
                 operation: async () => {
                     const startedAt = performance.now();
+                    await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [input.path]);
                     const response = await editFileTool(input, {
                         cwd: workspace.root,
                         root: workspace.root,
@@ -1525,6 +1706,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             operation: async () => {
                 const startedAt = performance.now();
                 try {
+                    await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [path, newPath]);
                     await renamePath({ path, newPath }, {
                         cwd: workspace.root,
                         allowedRoots: workspaces.fileToolRoots(workspace),
@@ -1596,6 +1778,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             operation: async () => {
                 const startedAt = performance.now();
                 try {
+                    await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [path]);
                     const deleted = await deletePath({ path, recursive }, {
                         cwd: workspace.root,
                         allowedRoots: workspaces.fileToolRoots(workspace),
@@ -1806,6 +1989,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                     operation: async () => {
                         const startedAt = performance.now();
                         const cwd = workspaces.resolveWorkingDirectory(workspace, workingDirectory);
+                        await assertWorkspaceInstructionsLoadedBeforeSideEffect(workspaces, workspace, [cwd]);
                         const snapshot = await processSessions.start({
                             workspaceId,
                             command,
@@ -1909,7 +2093,9 @@ export function createServer(config = loadConfig(), options = {}) {
         host: config.host,
         ...(allowedHosts ? { allowedHosts } : {}),
     });
-    const transports = new McpTransportRegistry();
+    const transports = new McpTransportRegistry({
+        maxTransports: MAX_MCP_TRANSPORT_SESSIONS,
+    });
     const mcpUrl = new URL("/mcp", config.publicBaseUrl);
     const resourceServerUrl = resourceUrlFromServerUrl(mcpUrl);
     const oauthProvider = new SingleUserOAuthProvider(config.oauth, mcpUrl, config.stateDir);
@@ -1939,7 +2125,7 @@ export function createServer(config = loadConfig(), options = {}) {
                 continue;
             }
             closedCount += 1;
-            if (reason === "idle_timeout") {
+            if (reason !== "server_shutdown") {
                 logEvent(config.logging, "debug", "mcp_transport_session_closed", {
                     reason,
                     transportSessionIdPrefix: transportSessionIdPrefix(result.transportSessionId),
@@ -1953,12 +2139,31 @@ export function createServer(config = loadConfig(), options = {}) {
             });
         }
     };
+    const logRuntimeResources = () => {
+        const memory = process.memoryUsage();
+        const processStats = processSessions.stats();
+        logEvent(config.logging, "debug", "runtime_resources", {
+            rssBytes: memory.rss,
+            heapUsedBytes: memory.heapUsed,
+            heapTotalBytes: memory.heapTotal,
+            externalBytes: memory.external,
+            arrayBuffersBytes: memory.arrayBuffers,
+            mcpTransports: transports.size,
+            processesTotal: processStats.total,
+            processesRunning: processStats.running,
+            processesCompleted: processStats.completed,
+            cachedWorkspaces: workspaces.cachedWorkspaceCount,
+            reviewStates: reviewCheckpoints.stateCount,
+        });
+    };
     const transportCleanupTimer = setInterval(() => {
         void transports
             .closeIdle(MCP_TRANSPORT_IDLE_TIMEOUT_MS)
-            .then((results) => logTransportCloseResults("idle_timeout", results));
+            .then((results) => logTransportCloseResults("idle_timeout", results))
+            .finally(logRuntimeResources);
     }, MCP_TRANSPORT_CLEANUP_INTERVAL_MS);
     transportCleanupTimer.unref();
+    logRuntimeResources();
     if (config.logging.trustProxy) {
         app.set("trust proxy", 1);
     }
@@ -2050,8 +2255,11 @@ export function createServer(config = loadConfig(), options = {}) {
                 transport = new StreamableHTTPServerTransport({
                     sessionIdGenerator: () => randomUUID(),
                     onsessioninitialized: (newTransportSessionId) => {
-                        if (transport)
-                            transports.register(newTransportSessionId, transport);
+                        if (transport) {
+                            void transports
+                                .register(newTransportSessionId, transport)
+                                .then((results) => logTransportCloseResults("capacity_limit", results));
+                        }
                         logEvent(config.logging, "debug", "mcp_transport_session_created", {
                             requestId,
                             transportSessionIdPrefix: transportSessionIdPrefix(newTransportSessionId),