@flyingrobots/graft 0.12.0 → 0.14.0

package/dist/mcp/workspace-router.js

@@ -7,12 +7,12 @@ import { RepoStateTracker } from "./repo-state.js";
 import { buildRuntimeStagedTarget } from "./runtime-staged-target.js";
 import { buildRuntimeWorkspaceOverlayFooting, } from "./runtime-workspace-overlay.js";
 import { buildWorkspaceReadObservation } from "./workspace-read-observation.js";
-import { DEFAULT_REPO_LOCAL_CAPABILITY_PROFILE, WorkspaceBindingRequiredError, WorkspaceRouteUnauthorizedError, } from "./workspace-router-model.js";
+import { DEFAULT_REPO_LOCAL_CAPABILITY_PROFILE, WorkspaceBindingRequiredError, WorkspaceResolutionError, WorkspaceRouteUnauthorizedError, } from "./workspace-router-model.js";
 import { resolveWorkspaceRequest, stableWorkspaceId } from "./workspace-router-resolution.js";
 import { DEFAULT_WARP_WRITER_ID } from "../warp/writer-id.js";
 import { GovernorTracker } from "../session/tracker.js";
-import { boundWorkspaceStatus, buildPersistedLocalHistoryContext, buildPersistedLocalHistoryContextFromExecution, buildPersistedLocalHistoryGraphContext, buildWorkspaceCausalContext, createBoundWorkspace, createWorkspaceSlice, nextBindingSliceDir, resolveCheckoutBoundaryHookEvent, unboundWorkspaceStatus, } from "./workspace-router-runtime.js";
-export { DEFAULT_DAEMON_CAPABILITY_PROFILE, DEFAULT_REPO_LOCAL_CAPABILITY_PROFILE, WorkspaceBindingRequiredError, WorkspaceCapabilityDeniedError, WorkspaceRouteUnauthorizedError, } from "./workspace-router-model.js";
+import { boundWorkspaceStatus, buildPersistedLocalHistoryContext, buildPersistedLocalHistoryContextFromExecution, buildPersistedLocalHistoryGraphContext, buildWorkspaceCausalContext, createBoundWorkspace, createWorkspaceWarpLease, createWorkspaceSlice, nextBindingSliceDir, resolveCheckoutBoundaryHookEvent, unboundWorkspaceStatus, } from "./workspace-router-runtime.js";
+export { DEFAULT_DAEMON_CAPABILITY_PROFILE, DEFAULT_REPO_LOCAL_CAPABILITY_PROFILE, WorkspaceBindingRequiredError, WorkspaceCapabilityDeniedError, WorkspaceResolutionError, WorkspaceRouteUnauthorizedError, } from "./workspace-router-model.js";
 export { resolveWorkspaceRequest } from "./workspace-router-resolution.js";
 const MAX_ROUTED_BINDINGS = 8;
 function workspaceCapabilityProfilesEqual(left, right) {
@@ -28,6 +28,7 @@ function workspaceCapabilityProfilesEqual(left, right) {
 export class WorkspaceRouter {
     options;
     bindingCounter = 0;
+    executionCounter = 0;
     sliceIdCounter = 0;
     currentSlice;
     currentBinding = null;
@@ -35,6 +36,8 @@ export class WorkspaceRouter {
     openedWorkspaces = new Map();
     routedBindings = new Map();
     routedBindingInitializations = new Map();
+    bindingCommitTail = Promise.resolve();
+    warpLeaseRelease = null;
     constructor(options) {
         this.options = options;
         const initialProjectRoot = options.mode === "repo_local" ? options.projectRoot : undefined;
@@ -78,14 +81,13 @@ export class WorkspaceRouter {
                 };
             const currentBinding = await this.createBoundWorkspace(initialWorkspace, this.options.graftDir, DEFAULT_REPO_LOCAL_CAPABILITY_PROFILE, undefined, this.currentSlice);
             const currentRepoState = currentBinding.slice.repoState;
-            if (currentRepoState === null) {
+            if (currentRepoState === null)
                 throw new WorkspaceBindingRequiredError("workspace");
-            }
             await currentRepoState.initialize();
-            await this.options.persistedLocalHistory.noteBinding({
+            await this.withBindingGraph(currentBinding, (currentGraph) => this.options.persistedLocalHistory.noteBinding({
                 current: this.buildPersistedLocalHistoryContext(currentBinding, currentRepoState.getState()),
-                currentGraph: await this.buildPersistedLocalHistoryGraphContext(currentBinding),
-            });
+                currentGraph,
+            }));
             this.currentBinding = currentBinding;
             this.noteOpenedWorkspace(initialWorkspace, DEFAULT_REPO_LOCAL_CAPABILITY_PROFILE, "startup", true);
         })();
@@ -118,25 +120,42 @@ export class WorkspaceRouter {
     getPathResolver() {
         return this.requireBinding().resolvePath;
     }
-    getWarp() {
-        return this.requireBinding().getWarp();
+    async withWarp(operation) {
+        const execution = this.captureExecutionContext();
+        try {
+            return await operation(await execution.getWarp());
+        }
+        finally {
+            await execution.releaseWarpLease();
+        }
     }
-    async observeRepoState() {
-        const binding = this.requireBinding();
-        const repoState = this.requireRepoState();
-        const previousObservation = repoState.getState();
-        const nextObservation = await repoState.observe();
+    releaseWarpLeases() {
+        if (this.warpLeaseRelease !== null)
+            return this.warpLeaseRelease;
+        // Bindings own metadata only. Already admitted operations release their
+        // own capabilities; retirement must not revoke those capabilities.
+        const pending = [this.initialization ?? Promise.resolve(), this.bindingCommitTail, ...this.routedBindingInitializations.values()];
+        this.warpLeaseRelease = Promise.allSettled(pending).then(() => undefined);
+        return this.warpLeaseRelease;
+    }
+    async observeRepoState(execution = null) {
+        const scope = this.resolveWorkspaceHistoryScope(execution);
+        if (scope === null) {
+            throw new WorkspaceBindingRequiredError("workspace");
+        }
+        const previousObservation = scope.repoState.getState();
+        const nextObservation = await scope.repoState.observe();
         const checkoutBoundaryHookEvent = previousObservation.checkoutEpoch !== nextObservation.checkoutEpoch
-            ? await this.resolveCheckoutBoundaryHookEvent(binding, previousObservation.observedAt, nextObservation)
+            ? await this.resolveCheckoutBoundaryHookEvent(scope, previousObservation.observedAt, nextObservation)
             : null;
-        const previousContext = this.buildPersistedLocalHistoryContext(binding, previousObservation);
-        const nextContext = this.buildPersistedLocalHistoryContext(binding, nextObservation, checkoutBoundaryHookEvent);
+        const previousContext = scope.buildHistoryContext(previousObservation);
+        const nextContext = scope.buildHistoryContext(nextObservation, checkoutBoundaryHookEvent);
         if (previousContext.checkoutEpochId !== nextContext.checkoutEpochId) {
-            await this.options.persistedLocalHistory.noteCheckoutBoundary({
+            await scope.withGraph((graph) => this.options.persistedLocalHistory.noteCheckoutBoundary({
                 previous: previousContext,
                 current: nextContext,
-                graph: await this.buildPersistedLocalHistoryGraphContext(binding),
-            });
+                graph,
+            }));
         }
     }
     getRepoState() {
@@ -231,9 +250,9 @@ export class WorkspaceRouter {
             ...(result.error !== undefined ? { error: result.error } : {}),
         };
     }
-    async getPersistedLocalHistorySummary() {
-        const binding = this.currentBinding;
-        if (binding?.slice.repoState === null || binding === null) {
+    async getPersistedLocalHistorySummary(execution = null) {
+        const scope = this.resolveWorkspaceHistoryScope(execution);
+        if (scope === null) {
             return {
                 availability: "none",
                 persistence: "persisted_local_history",
@@ -281,43 +300,43 @@ export class WorkspaceRouter {
                 nextAction: "bind_workspace_to_begin_local_history",
             };
         }
-        const status = this.getStatus();
-        const repoState = binding.slice.repoState.getState();
-        const causalContext = this.buildCausalContext(binding, repoState);
-        const graph = await this.buildPersistedLocalHistoryGraphContext(binding);
-        let summary = await this.options.persistedLocalHistory.summarize(status, causalContext, graph);
-        if (repoState.semanticTransition !== null) {
-            await this.options.persistedLocalHistory.noteSemanticTransitionObservation({
-                current: this.buildPersistedLocalHistoryContext(binding, repoState),
-                semanticTransition: repoState.semanticTransition,
-                transition: repoState.lastTransition,
-                attribution: summary.attribution,
-                graph,
-            });
-            summary = await this.options.persistedLocalHistory.summarize(status, causalContext, graph);
-        }
-        const stagedTarget = buildRuntimeStagedTarget(status, causalContext, repoState, summary.attribution);
-        if (stagedTarget.availability === "full_file") {
-            await this.options.persistedLocalHistory.noteStageObservation({
-                current: this.buildPersistedLocalHistoryContext(binding, repoState),
-                stagedTarget,
-                attribution: summary.attribution,
-                graph,
-            });
-            return this.options.persistedLocalHistory.summarize(status, causalContext, graph);
-        }
-        return summary;
+        const repoState = scope.repoState.getState();
+        const causalContext = scope.getCausalContext();
+        return scope.withGraph(async (graph) => {
+            let summary = await this.options.persistedLocalHistory.summarize(scope.status, causalContext, graph);
+            if (repoState.semanticTransition !== null) {
+                await this.options.persistedLocalHistory.noteSemanticTransitionObservation({
+                    current: scope.buildHistoryContext(repoState),
+                    semanticTransition: repoState.semanticTransition,
+                    transition: repoState.lastTransition,
+                    attribution: summary.attribution,
+                    graph,
+                });
+                summary = await this.options.persistedLocalHistory.summarize(scope.status, causalContext, graph);
+            }
+            const stagedTarget = buildRuntimeStagedTarget(scope.status, causalContext, repoState, summary.attribution);
+            if (stagedTarget.availability === "full_file") {
+                await this.options.persistedLocalHistory.noteStageObservation({
+                    current: scope.buildHistoryContext(repoState),
+                    stagedTarget,
+                    attribution: summary.attribution,
+                    graph,
+                });
+                return this.options.persistedLocalHistory.summarize(scope.status, causalContext, graph);
+            }
+            return summary;
+        });
     }
-    async getRepoConcurrencySummary() {
-        const binding = this.currentBinding;
-        if (binding?.slice.repoState === null || binding === null) {
+    async getRepoConcurrencySummary(execution = null) {
+        const scope = this.resolveWorkspaceHistoryScope(execution);
+        if (scope === null) {
             return null;
         }
-        return this.options.persistedLocalHistory.summarizeRepoConcurrency(this.getStatus(), await this.buildPersistedLocalHistoryGraphContext(binding));
+        return scope.withGraph((graph) => this.options.persistedLocalHistory.summarizeRepoConcurrency(scope.status, graph));
     }
-    async getPersistedLocalActivityWindow(limit) {
-        const binding = this.currentBinding;
-        if (binding?.slice.repoState === null || binding === null) {
+    async getPersistedLocalActivityWindow(limit, execution = null) {
+        const scope = this.resolveWorkspaceHistoryScope(execution);
+        if (scope === null) {
             return {
                 historyPath: null,
                 limit,
@@ -326,36 +345,49 @@ export class WorkspaceRouter {
                 items: [],
             };
         }
-        await this.getPersistedLocalHistorySummary();
-        const status = this.getStatus();
-        const repoState = binding.slice.repoState.getState();
-        const causalContext = this.buildCausalContext(binding, repoState);
-        const graph = await this.buildPersistedLocalHistoryGraphContext(binding);
-        return this.options.persistedLocalHistory.listRecentActivity(status, causalContext, limit, graph);
+        await this.getPersistedLocalHistorySummary(execution);
+        const causalContext = scope.getCausalContext();
+        return scope.withGraph((graph) => this.options.persistedLocalHistory.listRecentActivity(scope.status, causalContext, limit, graph));
     }
-    getWorkspaceOverlayFooting() {
-        const binding = this.currentBinding;
-        if (binding?.slice.repoState === null || binding === null) {
+    getWorkspaceOverlayFooting(execution = null) {
+        const scope = this.resolveWorkspaceHistoryScope(execution);
+        if (scope === null) {
             return Promise.resolve(null);
         }
-        return buildRuntimeWorkspaceOverlayFooting(this.options.fs, this.options.git, binding.worktreeRoot, binding.gitCommonDir, binding.slice.repoState.getState());
+        return buildRuntimeWorkspaceOverlayFooting(this.options.fs, this.options.git, scope.worktreeRoot, scope.gitCommonDir, scope.repoState.getState());
     }
     async noteReadObservation(toolName, args, result, execution) {
-        const active = execution ?? this.captureCurrentExecutionContext();
+        const ownedExecution = execution === null || execution === undefined
+            ? this.captureCurrentExecutionContext()
+            : null;
+        const active = execution ?? ownedExecution;
         if (active === null) {
             return;
         }
-        const readObservation = buildWorkspaceReadObservation(active, toolName, args, result);
-        if (readObservation === null) {
-            return;
+        try {
+            const readObservation = buildWorkspaceReadObservation(active, toolName, args, result);
+            if (readObservation === null) {
+                return;
+            }
+            const summary = await this.options.persistedLocalHistory.summarize(active.status, active.getCausalContext(), await this.buildPersistedLocalHistoryGraphContextFromExecution(active));
+            await this.options.persistedLocalHistory.noteReadObservation({
+                current: this.buildPersistedLocalHistoryContextFromExecution(active, active.repoState.getState()),
+                attribution: summary.attribution,
+                graph: await this.buildPersistedLocalHistoryGraphContextFromExecution(active),
+                ...readObservation,
+            });
+        }
+        finally {
+            await ownedExecution?.releaseWarpLease();
         }
-        const summary = await this.options.persistedLocalHistory.summarize(active.status, active.getCausalContext(), await this.buildPersistedLocalHistoryGraphContextFromExecution(active));
-        await this.options.persistedLocalHistory.noteReadObservation({
-            current: this.buildPersistedLocalHistoryContextFromExecution(active, active.repoState.getState()),
-            attribution: summary.attribution,
-            graph: await this.buildPersistedLocalHistoryGraphContextFromExecution(active),
-            ...readObservation,
-        });
+    }
+    getRuntimeCausalContext() {
+        const binding = this.currentBinding;
+        const repoState = binding?.slice.repoState;
+        if (binding === null || repoState === null || repoState === undefined) {
+            return null;
+        }
+        return this.buildCausalContext(binding, repoState.getState());
     }
     captureExecutionContext() {
         const binding = this.requireBinding();
@@ -364,31 +396,50 @@ export class WorkspaceRouter {
     async captureExecutionContextForWorkspace(request) {
         const resolved = await resolveWorkspaceRequest(this.options.git, request);
         if ("code" in resolved) {
-            throw new Error(resolved.message);
-        }
+            throw new WorkspaceResolutionError(resolved.code, resolved.message);
+        }
+        const workspaceRoute = Object.freeze({
+            route: "explicit_cwd",
+            requestedRoot: path.resolve(request.cwd),
+            resolvedRoot: resolved.worktreeRoot,
+            repoId: resolved.repoId,
+            worktreeId: resolved.worktreeId,
+        });
         const capabilityProfile = this.options.mode === "repo_local"
             ? DEFAULT_REPO_LOCAL_CAPABILITY_PROFILE
             : (await this.options.authorizationPolicy?.getCapabilityProfile(resolved)) ?? null;
         if (capabilityProfile === null) {
-            this.routedBindings.delete(resolved.worktreeId);
-            this.routedBindingInitializations.delete(resolved.worktreeId);
+            const cached = this.routedBindings.get(resolved.worktreeId);
+            if (cached !== undefined) {
+                this.disposeRoutedBinding(cached);
+            }
+            const initializing = this.routedBindingInitializations.get(resolved.worktreeId);
+            if (initializing !== undefined) {
+                if (this.routedBindingInitializations.get(resolved.worktreeId) === initializing) {
+                    this.routedBindingInitializations.delete(resolved.worktreeId);
+                }
+                const initialized = await initializing.catch(() => null);
+                if (initialized !== null && initialized !== cached) {
+                    this.disposeRoutedBinding(initialized);
+                }
+            }
             throw new WorkspaceRouteUnauthorizedError(resolved.worktreeRoot);
         }
-        if (this.currentBinding?.worktreeId === resolved.worktreeId
-            && workspaceCapabilityProfilesEqual(this.currentBinding.capabilityProfile, capabilityProfile)) {
-            return this.captureExecutionContext();
+        if (this.currentBinding !== null
+            && this.routedBindingMatches(this.currentBinding, resolved, capabilityProfile)) {
+            return this.buildExecutionContext(this.currentBinding, workspaceRoute);
         }
         const existing = this.routedBindings.get(resolved.worktreeId);
         if (existing !== undefined && this.routedBindingMatches(existing, resolved, capabilityProfile)) {
             this.noteRoutedBinding(existing);
-            return this.buildExecutionContext(existing);
+            return this.buildExecutionContext(existing, workspaceRoute);
         }
         const initializing = this.routedBindingInitializations.get(resolved.worktreeId);
         if (initializing !== undefined) {
             const binding = await initializing;
             if (this.routedBindingMatches(binding, resolved, capabilityProfile)) {
                 this.noteRoutedBinding(binding);
-                return this.buildExecutionContext(binding);
+                return this.buildExecutionContext(binding, workspaceRoute);
             }
         }
         const bindingInitialization = this.createRoutedBinding(resolved, capabilityProfile);
@@ -404,16 +455,15 @@ export class WorkspaceRouter {
         }
         this.noteRoutedBinding(binding);
         this.noteOpenedWorkspace(resolved, capabilityProfile, this.options.mode === "daemon" ? "daemon_authorized" : "session_opened", false);
-        return this.buildExecutionContext(binding);
+        return this.buildExecutionContext(binding, workspaceRoute);
     }
     async createRoutedBinding(resolved, capabilityProfile) {
         const routeDir = path.join(this.options.graftDir, "routes", `slice-${String(++this.bindingCounter).padStart(4, "0")}`);
         await this.options.fs.mkdir(routeDir, { recursive: true });
         const binding = await this.createBoundWorkspace(resolved, routeDir, capabilityProfile, undefined);
         const repoState = binding.slice.repoState;
-        if (repoState === null) {
+        if (repoState === null)
             throw new WorkspaceBindingRequiredError("workspace");
-        }
         await repoState.initialize();
         return binding;
     }
@@ -424,21 +474,50 @@ export class WorkspaceRouter {
             && workspaceCapabilityProfilesEqual(binding.capabilityProfile, capabilityProfile);
     }
     noteRoutedBinding(binding) {
+        const replaced = this.routedBindings.get(binding.worktreeId);
         this.routedBindings.delete(binding.worktreeId);
         this.routedBindings.set(binding.worktreeId, binding);
+        if (replaced !== undefined && replaced !== binding) {
+            this.disposeRoutedBinding(replaced);
+        }
         while (this.routedBindings.size > MAX_ROUTED_BINDINGS) {
-            const oldest = this.routedBindings.keys().next().value;
-            if (oldest === undefined) {
+            const oldestKey = this.routedBindings.keys().next().value;
+            if (oldestKey === undefined) {
                 return;
             }
-            this.routedBindings.delete(oldest);
+            const evicted = this.routedBindings.get(oldestKey);
+            if (evicted !== undefined) {
+                this.disposeRoutedBinding(evicted);
+            }
+            else {
+                this.routedBindings.delete(oldestKey);
+            }
+        }
+    }
+    disposeRoutedBinding(binding) {
+        if (this.routedBindings.get(binding.worktreeId) === binding) {
+            this.routedBindings.delete(binding.worktreeId);
         }
     }
-    buildExecutionContext(binding) {
+    buildExecutionContext(binding, workspaceRoute = null) {
+        if (this.warpLeaseRelease !== null) {
+            throw new Error("workspace WARP leases have already been released");
+        }
         const repoState = binding.slice.repoState;
         if (repoState === null) {
             throw new WorkspaceBindingRequiredError("workspace");
         }
+        const warpLease = createWorkspaceWarpLease({
+            repoId: binding.repoId,
+            worktreeRoot: binding.worktreeRoot,
+            writerId: binding.warpWriterId,
+            ownerId: [
+                binding.transportSessionId,
+                "execution",
+                String(++this.executionCounter).padStart(6, "0"),
+            ].join(":"),
+            warpPool: this.options.warpPool,
+        });
         return {
             sliceId: binding.slice.sliceId,
             repoId: binding.repoId,
@@ -446,18 +525,22 @@ export class WorkspaceRouter {
             projectRoot: binding.worktreeRoot,
             worktreeRoot: binding.worktreeRoot,
             gitCommonDir: binding.gitCommonDir,
+            workspaceRoute,
             graftignorePatterns: binding.graftignorePatterns,
             resolvePath: binding.resolvePath,
             capabilityProfile: binding.capabilityProfile,
             warpWriterId: binding.warpWriterId,
-            getCausalContext: () => this.buildCausalContext(binding, repoState.getState()),
+            getCausalContext: (observation) => {
+                return this.buildCausalContext(binding, observation ?? repoState.getState());
+            },
             status: boundWorkspaceStatus(this.options.mode, binding),
             governor: binding.slice.governor,
             cache: binding.slice.cache,
             metrics: binding.slice.metrics,
             graftDir: binding.slice.graftDir,
             repoState,
-            getWarp: binding.getWarp,
+            getWarp: () => warpLease.getWarp(),
+            releaseWarpLease: () => warpLease.release(),
         };
     }
     async bind(request, actionName) {
@@ -476,51 +559,51 @@ export class WorkspaceRouter {
         }
         return this.bindInternal("rebind", request, actionName);
     }
-    async declareAttach(declaration) {
-        const binding = this.currentBinding;
-        if (binding?.slice.repoState === null || binding === null) {
+    async declareAttach(declaration, execution = null) {
+        const scope = this.resolveWorkspaceHistoryScope(execution);
+        if (scope === null) {
             return {
                 ok: false,
                 action: "attach",
                 ...this.getStatus(),
-                persistedLocalHistory: await this.getPersistedLocalHistorySummary(),
+                persistedLocalHistory: await this.getPersistedLocalHistorySummary(execution),
                 errorCode: "UNBOUND_SESSION",
                 error: "causal_attach requires an active workspace binding.",
             };
         }
         try {
-            await this.options.persistedLocalHistory.declareAttach({
-                current: this.buildPersistedLocalHistoryContext(binding, binding.slice.repoState.getState()),
+            await scope.withGraph((graph) => this.options.persistedLocalHistory.declareAttach({
+                current: scope.buildHistoryContext(scope.repoState.getState()),
                 declaration,
-                graph: await this.buildPersistedLocalHistoryGraphContext(binding),
-            });
+                graph,
+            }));
         }
         catch (error) {
             if (error instanceof PersistedLocalHistoryAttachUnavailableError) {
                 const sharedAttachSource = this.options.sharedAttachPolicy?.resolveSharedAttachSource({
                     sessionId: this.options.transportSessionId,
-                    repoId: binding.repoId,
-                    worktreeId: binding.worktreeId,
+                    repoId: scope.repoId,
+                    worktreeId: scope.worktreeId,
                 }) ?? null;
                 if (sharedAttachSource !== null) {
-                    await this.options.persistedLocalHistory.declareSharedAttach({
-                        current: this.buildPersistedLocalHistoryContext(binding, binding.slice.repoState.getState()),
+                    await scope.withGraph((graph) => this.options.persistedLocalHistory.declareSharedAttach({
+                        current: scope.buildHistoryContext(scope.repoState.getState()),
                         declaration,
                         source: sharedAttachSource,
-                        graph: await this.buildPersistedLocalHistoryGraphContext(binding),
-                    });
+                        graph,
+                    }));
                     return {
                         ok: true,
                         action: "attach",
-                        ...this.getStatus(),
-                        persistedLocalHistory: await this.getPersistedLocalHistorySummary(),
+                        ...scope.status,
+                        persistedLocalHistory: await this.getPersistedLocalHistorySummary(execution),
                     };
                 }
                 return {
                     ok: false,
                     action: "attach",
-                    ...this.getStatus(),
-                    persistedLocalHistory: await this.getPersistedLocalHistorySummary(),
+                    ...scope.status,
+                    persistedLocalHistory: await this.getPersistedLocalHistorySummary(execution),
                     errorCode: error.code,
                     error: error.message,
                 };
@@ -530,8 +613,8 @@ export class WorkspaceRouter {
         return {
             ok: true,
             action: "attach",
-            ...this.getStatus(),
-            persistedLocalHistory: await this.getPersistedLocalHistorySummary(),
+            ...scope.status,
+            persistedLocalHistory: await this.getPersistedLocalHistorySummary(execution),
         };
     }
     async bindInternal(action, request, actionName, options = {}) {
@@ -561,27 +644,31 @@ export class WorkspaceRouter {
                 error: `Workspace ${resolved.worktreeRoot} is not authorized for daemon binding. Call workspace_authorize first.`,
             };
         }
+        return this.enqueueBindingCommit(() => this.commitBinding(action, resolved, sliceDir, capabilityProfile, actionName, options));
+    }
+    enqueueBindingCommit(operation) {
+        const result = this.bindingCommitTail.then(operation);
+        this.bindingCommitTail = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async commitBinding(action, resolved, sliceDir, capabilityProfile, actionName, options) {
+        const previousBinding = this.currentBinding;
         const nextBinding = await this.createBoundWorkspace(resolved, sliceDir, capabilityProfile, actionName);
         const nextRepoState = nextBinding.slice.repoState;
-        if (nextRepoState === null) {
+        if (nextRepoState === null)
             throw new WorkspaceBindingRequiredError("workspace");
-        }
         await nextRepoState.initialize();
-        const previousBinding = this.currentBinding;
         const previousRepoState = previousBinding?.slice.repoState;
-        await this.options.persistedLocalHistory.noteBinding({
-            current: this.buildPersistedLocalHistoryContext(nextBinding, nextRepoState.getState()),
-            previous: previousBinding === null || previousRepoState == null
-                ? null
-                : this.buildPersistedLocalHistoryContext(previousBinding, previousRepoState.getState()),
-            currentGraph: await this.buildPersistedLocalHistoryGraphContext(nextBinding),
-            previousGraph: previousBinding === null
-                ? null
-                : await this.buildPersistedLocalHistoryGraphContext(previousBinding),
-        });
-        if (this.options.mode === "daemon") {
+        const current = this.buildPersistedLocalHistoryContext(nextBinding, nextRepoState.getState());
+        const previous = previousBinding === null || previousRepoState == null
+            ? null
+            : this.buildPersistedLocalHistoryContext(previousBinding, previousRepoState.getState());
+        if (previous !== null && (previous.repoId !== current.repoId || previous.worktreeId !== current.worktreeId)) {
+            await this.withBindingGraph(previousBinding, (previousGraph) => this.options.persistedLocalHistory.noteBindingDeparture({ current, previous, previousGraph }));
+        }
+        await this.withBindingGraph(nextBinding, (currentGraph) => this.options.persistedLocalHistory.noteBinding({ current, previous, currentGraph }));
+        if (this.options.mode === "daemon")
             await this.options.authorizationPolicy?.noteBound(resolved);
-        }
         this.currentBinding = nextBinding;
         this.currentSlice = nextBinding.slice;
         this.noteOpenedWorkspace(resolved, capabilityProfile, options.openedSource ?? (this.options.mode === "daemon" ? "daemon_authorized" : "session_opened"), true);
@@ -600,6 +687,8 @@ export class WorkspaceRouter {
             git: this.options.git,
             nextSliceId: `slice-${String(++this.sliceIdCounter).padStart(4, "0")}`,
         });
+        if (this.warpLeaseRelease !== null)
+            throw new Error("workspace graph admission has closed");
         return createBoundWorkspace({
             resolved,
             graftDir,
@@ -609,7 +698,6 @@ export class WorkspaceRouter {
             fs: this.options.fs,
             transportSessionId: this.options.transportSessionId,
             warpWriterId: this.options.warpWriterId ?? DEFAULT_WARP_WRITER_ID,
-            warpPool: this.options.warpPool,
         });
     }
     requireBinding() {
@@ -685,11 +773,12 @@ export class WorkspaceRouter {
             hookEvent,
         });
     }
-    buildPersistedLocalHistoryContextFromExecution(execution, observation) {
+    buildPersistedLocalHistoryContextFromExecution(execution, observation, hookEvent = null) {
         return buildPersistedLocalHistoryContextFromExecution({
             persistedLocalHistory: this.options.persistedLocalHistory,
             execution,
             observation,
+            hookEvent,
         });
     }
     async resolveCheckoutBoundaryHookEvent(binding, previousObservedAt, observation) {
@@ -707,11 +796,59 @@ export class WorkspaceRouter {
         }
         return this.captureExecutionContext();
     }
-    async buildPersistedLocalHistoryGraphContext(binding) {
-        if (this.options.persistedLocalHistoryGraph === false) {
+    resolveWorkspaceHistoryScope(execution) {
+        if (execution !== null) {
+            return {
+                status: execution.status,
+                repoId: execution.repoId,
+                worktreeId: execution.worktreeId,
+                worktreeRoot: execution.worktreeRoot,
+                gitCommonDir: execution.gitCommonDir,
+                repoState: execution.repoState,
+                getCausalContext: () => execution.getCausalContext(),
+                buildHistoryContext: (observation, hookEvent) => {
+                    return this.buildPersistedLocalHistoryContextFromExecution(execution, observation, hookEvent);
+                },
+                withGraph: async (operation) => operation(await this.buildPersistedLocalHistoryGraphContextFromExecution(execution)),
+            };
+        }
+        const binding = this.currentBinding;
+        const repoState = binding?.slice.repoState;
+        if (binding === null || repoState === null || repoState === undefined) {
             return null;
         }
-        return buildPersistedLocalHistoryGraphContext(binding.worktreeRoot, binding.getWarp);
+        return {
+            status: boundWorkspaceStatus(this.options.mode, binding),
+            repoId: binding.repoId,
+            worktreeId: binding.worktreeId,
+            worktreeRoot: binding.worktreeRoot,
+            gitCommonDir: binding.gitCommonDir,
+            repoState,
+            getCausalContext: () => this.buildCausalContext(binding, repoState.getState()),
+            buildHistoryContext: (observation, hookEvent) => {
+                return this.buildPersistedLocalHistoryContext(binding, observation, hookEvent);
+            },
+            withGraph: (operation) => this.withBindingGraph(binding, operation),
+        };
+    }
+    async withBindingGraph(binding, operation) {
+        if (this.warpLeaseRelease !== null)
+            throw new Error("workspace graph admission has closed");
+        if (binding === null || this.options.persistedLocalHistoryGraph === false)
+            return operation(null);
+        const lease = createWorkspaceWarpLease({
+            repoId: binding.repoId,
+            worktreeRoot: binding.worktreeRoot,
+            writerId: binding.warpWriterId,
+            ownerId: binding.transportSessionId + ":history:" + String(++this.executionCounter),
+            warpPool: this.options.warpPool,
+        });
+        try {
+            return await operation(await buildPersistedLocalHistoryGraphContext(binding.worktreeRoot, () => lease.getWarp()));
+        }
+        finally {
+            await lease.release();
+        }
     }
     async buildPersistedLocalHistoryGraphContextFromExecution(execution) {
         if (this.options.persistedLocalHistoryGraph === false) {