@akira-tl/forgerelay 0.3.6 → 0.4.0

package/dist/review-checkpoints.js

@@ -3,26 +3,60 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { git, getGitEligibility, safeWorkspaceRefSegment } from "./git.js";
 const REVIEW_REF_PREFIX = "refs/devspace/review";
-export function createReviewCheckpointManager() {
+const DEFAULT_MAX_REVIEW_WORKSPACE_STATES = 128;
+export function createReviewCheckpointManager(options = {}) {
+    const maxWorkspaceStates = options.maxWorkspaceStates ?? DEFAULT_MAX_REVIEW_WORKSPACE_STATES;
+    if (!Number.isInteger(maxWorkspaceStates) || maxWorkspaceStates < 1) {
+        throw new Error("Review checkpoint workspace-state limit must be a positive integer.");
+    }
     const states = new Map();
     const initializations = new Map();
+    const touchState = (workspaceId) => {
+        const state = states.get(workspaceId);
+        if (!state)
+            return;
+        states.delete(workspaceId);
+        states.set(workspaceId, state);
+    };
+    const trimStates = () => {
+        while (states.size > maxWorkspaceStates) {
+            const oldestWorkspaceId = states.keys().next().value;
+            if (!oldestWorkspaceId)
+                break;
+            states.delete(oldestWorkspaceId);
+        }
+    };
     return {
+        get stateCount() {
+            return states.size;
+        },
+        async releaseWorkspace(workspaceId) {
+            const pending = initializations.get(workspaceId);
+            if (pending)
+                await pending;
+            states.delete(workspaceId);
+        },
         async initializeWorkspace({ workspaceId, root }) {
             const existingState = states.get(workspaceId);
             assertWorkspaceRoot(existingState, workspaceId, root);
             if (existingState?.root === root && existingState.gitRoot !== undefined) {
+                touchState(workspaceId);
                 return;
             }
             const pending = initializations.get(workspaceId);
             if (pending) {
                 await pending;
                 assertWorkspaceRoot(states.get(workspaceId), workspaceId, root);
+                touchState(workspaceId);
+                trimStates();
                 return;
             }
             const initialize = initializeWorkspaceState(states, workspaceId, root);
             initializations.set(workspaceId, initialize);
             try {
                 await initialize;
+                touchState(workspaceId);
+                trimStates();
             }
             finally {
                 if (initializations.get(workspaceId) === initialize) {
@@ -38,6 +72,7 @@ export function createReviewCheckpointManager() {
                 state = states.get(workspaceId);
             }
             assertWorkspaceRoot(state, workspaceId, root);
+            touchState(workspaceId);
             if (!state?.gitRoot) {
                 throw new Error(state?.diagnostic ?? "review.changes requires a Git workspace in this version.");
             }

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";
@@ -20,6 +21,7 @@ import { deletePath, renamePath } from "./file-mutations.js";
 import { downloadIncomingArtifact, isArtifactDownloadSupportedPlatform, } from "./artifact-tools.js";
 import { ArtifactError } from "./artifact-error.js";
 import { loadConfig } from "./config.js";
+import { CodeIntelligenceError, CodeIntelligenceManager } from "./lsp/code-intelligence.js";
 import { attachHookReports, HookRunner, runToolWithHooks } from "./hooks.js";
 import { checkHookConfiguration } from "./hook-cli.js";
 import { buildServerInstructions, buildShellMutationPolicy, buildToolDescriptions, toolNames, } from "./mcp/server-instructions.js";
@@ -42,6 +44,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 +95,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}` : "";
@@ -608,6 +635,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,
@@ -716,7 +744,7 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
         });
     });
 }
-export function createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters) {
+export function createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence) {
     const toolDescriptions = buildToolDescriptions(config);
     const hooks = new HookRunner(config.hooks, config.logging, process.env, (workspaceId, result) => attachCompletedProcessNotices(processSessions, workspaceId, result));
     const incomingArtifactRegistry = new IncomingArtifactAdapterRegistry(incomingArtifactAdapters);
@@ -724,6 +752,22 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
     const reviewChangesAvailable = config.widgets === "changes";
     const capabilityRegistry = createCapabilityRegistry({
         inspectHooks: (workspaceRoot) => checkHookConfiguration(workspaceRoot, config.hooks),
+        codeIntelligence: {
+            available: true,
+            run: async (input, context) => {
+                try {
+                    return {
+                        value: await codeIntelligence.definition(context.workspaceRoot, input),
+                    };
+                }
+                catch (error) {
+                    if (error instanceof CodeIntelligenceError) {
+                        throw new CapabilityError(error.code, error.message);
+                    }
+                    throw error;
+                }
+            },
+        },
         reviewChanges: {
             available: reviewChangesAvailable,
             unavailableReason: reviewChangesAvailable
@@ -1337,14 +1381,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.`,
@@ -1384,6 +1429,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)],
@@ -1417,7 +1463,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) => {
@@ -1430,6 +1478,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,
@@ -1444,6 +1493,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,
@@ -1458,6 +1513,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
                 });
                 return {
                     ...response,
+                    content,
                     _meta: {
                         tool: toolNames.read,
                         card: {
@@ -1468,7 +1524,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,
+                                })),
+                            }
+                            : {}),
                     },
                 };
             },
@@ -1500,6 +1564,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,
@@ -1582,6 +1647,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,
@@ -1657,6 +1723,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),
@@ -1728,6 +1795,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),
@@ -1938,6 +2006,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,
@@ -2041,7 +2110,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);
@@ -2054,6 +2125,7 @@ export function createServer(config = loadConfig(), options = {}) {
     const workspaces = new WorkspaceRegistry(config, workspaceStore);
     const reviewCheckpoints = createReviewCheckpointManager();
     const processSessions = new ProcessManager();
+    const codeIntelligence = new CodeIntelligenceManager(config);
     const localAgentProviders = config.subagents
         ? getLocalAgentProviderAvailabilitySnapshot()
         : [];
@@ -2071,7 +2143,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),
@@ -2085,12 +2157,32 @@ 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,
+            languageServices: codeIntelligence.size,
+        });
+    };
     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);
     }
@@ -2182,8 +2274,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),
@@ -2200,7 +2295,7 @@ export function createServer(config = loadConfig(), options = {}) {
                         });
                     }
                 };
-                const server = createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters);
+                const server = createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence);
                 await server.connect(transport);
             }
             else {
@@ -2230,6 +2325,7 @@ export function createServer(config = loadConfig(), options = {}) {
                 const results = await transports.closeAll();
                 logTransportCloseResults("server_shutdown", results);
                 processSessions.shutdown();
+                await codeIntelligence.shutdown();
                 oauthProvider.close();
                 workspaceStore.close?.();
             })();

package/dist/workspace-store.js

@@ -1,13 +1,32 @@
 import { and, desc, eq } from "drizzle-orm";
 import { openDatabase } from "./db/client.js";
 import { workspaceContextDeliveries, workspaceConversationBindings, workspaceSessions, } from "./db/schema.js";
+const DEFAULT_TOUCH_FLUSH_INTERVAL_MS = 5 * 60 * 1_000;
 export class SqliteWorkspaceStore {
     database;
-    constructor(stateDir) {
+    now;
+    touchFlushTimer;
+    pendingSessionTouches = new Map();
+    pendingConversationTouches = new Map();
+    constructor(stateDir, options = {}) {
         this.database = openDatabase(stateDir);
+        this.now = options.now ?? (() => new Date());
+        const touchFlushIntervalMs = options.touchFlushIntervalMs ?? DEFAULT_TOUCH_FLUSH_INTERVAL_MS;
+        if (!Number.isInteger(touchFlushIntervalMs) || touchFlushIntervalMs < 1) {
+            throw new Error("Workspace touch flush interval must be a positive integer.");
+        }
+        this.touchFlushTimer = setInterval(() => {
+            try {
+                this.flushTouches();
+            }
+            catch (error) {
+                console.warn(`ForgeRelay workspace touch flush failed: ${errorMessage(error)}`);
+            }
+        }, touchFlushIntervalMs);
+        this.touchFlushTimer.unref();
     }
     createSession(input) {
-        const now = new Date().toISOString();
+        const now = this.now().toISOString();
         const session = {
             id: input.id,
             root: input.root,
@@ -47,19 +66,18 @@ export class SqliteWorkspaceStore {
             .from(workspaceSessions)
             .where(eq(workspaceSessions.id, id))
             .get();
-        return row ? rowToWorkspaceSession(row) : undefined;
+        if (!row)
+            return undefined;
+        return applySessionTouch(rowToWorkspaceSession(row), this.pendingSessionTouches.get(id));
     }
     touchSession(id) {
-        this.database.db
-            .update(workspaceSessions)
-            .set({ lastUsedAt: new Date().toISOString() })
-            .where(eq(workspaceSessions.id, id))
-            .run();
+        this.pendingSessionTouches.set(id, this.now().toISOString());
     }
     setSessionStatus(id, status) {
+        this.pendingSessionTouches.delete(id);
         this.database.db
             .update(workspaceSessions)
-            .set({ status, lastUsedAt: new Date().toISOString() })
+            .set({ status, lastUsedAt: this.now().toISOString() })
             .where(eq(workspaceSessions.id, id))
             .run();
     }
@@ -77,9 +95,13 @@ export class SqliteWorkspaceStore {
             : conditions.length === 1
                 ? query.where(conditions[0]).all()
                 : query.where(and(...conditions)).all();
-        return rows.map(rowToWorkspaceSession);
+        return rows
+            .map(rowToWorkspaceSession)
+            .map((session) => applySessionTouch(session, this.pendingSessionTouches.get(session.id)))
+            .sort((left, right) => right.lastUsedAt.localeCompare(left.lastUsedAt));
     }
     deleteSession(id) {
+        this.pendingSessionTouches.delete(id);
         this.database.db
             .delete(workspaceSessions)
             .where(eq(workspaceSessions.id, id))
@@ -90,7 +112,8 @@ export class SqliteWorkspaceStore {
             .select()
             .from(workspaceConversationBindings)
             .all()
-            .map(rowToWorkspaceConversationBinding);
+            .map(rowToWorkspaceConversationBinding)
+            .map((binding) => applyConversationTouch(binding, this.pendingConversationTouches.get(conversationTouchKey(binding.conversationScopeId, binding.targetKey))?.lastUsedAt));
     }
     getConversationBinding(conversationScopeId, targetKey) {
         const row = this.database.db
@@ -98,10 +121,13 @@ export class SqliteWorkspaceStore {
             .from(workspaceConversationBindings)
             .where(and(eq(workspaceConversationBindings.conversationScopeId, conversationScopeId), eq(workspaceConversationBindings.targetKey, targetKey)))
             .get();
-        return row ? rowToWorkspaceConversationBinding(row) : undefined;
+        if (!row)
+            return undefined;
+        const binding = rowToWorkspaceConversationBinding(row);
+        return applyConversationTouch(binding, this.pendingConversationTouches.get(conversationTouchKey(conversationScopeId, targetKey))?.lastUsedAt);
     }
     setConversationBinding(input) {
-        const now = new Date().toISOString();
+        const now = this.now().toISOString();
         const row = this.database.db
             .insert(workspaceConversationBindings)
             .values({
@@ -126,16 +152,18 @@ export class SqliteWorkspaceStore {
         if (!row) {
             throw new Error("Conversation workspace binding upsert returned no row.");
         }
+        this.pendingConversationTouches.delete(conversationTouchKey(input.conversationScopeId, input.targetKey));
         return rowToWorkspaceConversationBinding(row);
     }
     touchConversationBinding(conversationScopeId, targetKey) {
-        this.database.db
-            .update(workspaceConversationBindings)
-            .set({ lastUsedAt: new Date().toISOString() })
-            .where(and(eq(workspaceConversationBindings.conversationScopeId, conversationScopeId), eq(workspaceConversationBindings.targetKey, targetKey)))
-            .run();
+        this.pendingConversationTouches.set(conversationTouchKey(conversationScopeId, targetKey), {
+            conversationScopeId,
+            targetKey,
+            lastUsedAt: this.now().toISOString(),
+        });
     }
     deleteConversationBinding(conversationScopeId, targetKey) {
+        this.pendingConversationTouches.delete(conversationTouchKey(conversationScopeId, targetKey));
         this.database.db
             .delete(workspaceConversationBindings)
             .where(and(eq(workspaceConversationBindings.conversationScopeId, conversationScopeId), eq(workspaceConversationBindings.targetKey, targetKey)))
@@ -184,13 +212,62 @@ export class SqliteWorkspaceStore {
             .where(and(eq(workspaceContextDeliveries.conversationScopeId, conversationScopeId), eq(workspaceContextDeliveries.targetKey, targetKey)))
             .run();
     }
+    get pendingTouchCount() {
+        return this.pendingSessionTouches.size + this.pendingConversationTouches.size;
+    }
+    flushTouches() {
+        if (this.pendingTouchCount === 0)
+            return;
+        const sessionTouches = [...this.pendingSessionTouches.entries()];
+        const conversationTouches = [...this.pendingConversationTouches.values()];
+        const updateSession = this.database.sqlite.prepare("UPDATE workspace_sessions SET last_used_at = ? WHERE id = ?");
+        const updateConversation = this.database.sqlite.prepare("UPDATE workspace_conversation_bindings SET last_used_at = ? WHERE conversation_scope_id = ? AND target_key = ?");
+        const flush = this.database.sqlite.transaction(() => {
+            for (const [workspaceId, lastUsedAt] of sessionTouches) {
+                updateSession.run(lastUsedAt, workspaceId);
+            }
+            for (const touch of conversationTouches) {
+                updateConversation.run(touch.lastUsedAt, touch.conversationScopeId, touch.targetKey);
+            }
+        });
+        flush();
+        for (const [workspaceId, lastUsedAt] of sessionTouches) {
+            if (this.pendingSessionTouches.get(workspaceId) === lastUsedAt) {
+                this.pendingSessionTouches.delete(workspaceId);
+            }
+        }
+        for (const touch of conversationTouches) {
+            const key = conversationTouchKey(touch.conversationScopeId, touch.targetKey);
+            if (this.pendingConversationTouches.get(key)?.lastUsedAt === touch.lastUsedAt) {
+                this.pendingConversationTouches.delete(key);
+            }
+        }
+    }
     close() {
-        this.database.close();
+        clearInterval(this.touchFlushTimer);
+        try {
+            this.flushTouches();
+        }
+        finally {
+            this.database.close();
+        }
     }
 }
 export function createWorkspaceStore(stateDir) {
     return new SqliteWorkspaceStore(stateDir);
 }
+function applySessionTouch(session, lastUsedAt) {
+    return lastUsedAt ? { ...session, lastUsedAt } : session;
+}
+function applyConversationTouch(binding, lastUsedAt) {
+    return lastUsedAt ? { ...binding, lastUsedAt } : binding;
+}
+function conversationTouchKey(conversationScopeId, targetKey) {
+    return JSON.stringify([conversationScopeId, targetKey]);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function rowToWorkspaceSession(row) {
     return {
         id: row.id,